Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

TAO_Notify_Method_Request_Dispatch Class Reference

#include <Method_Request_Dispatch.h>

Inheritance diagram for TAO_Notify_Method_Request_Dispatch:

Inheritance graph
[legend]
Collaboration diagram for TAO_Notify_Method_Request_Dispatch:

Collaboration graph
[legend]
List of all members.

Public Types

enum  { persistence_code = 1 }
 an arbitrary code (Octet) to identify this delivery method type in persistent storage More...


Public Member Functions

 TAO_Notify_Method_Request_Dispatch (const TAO_Notify_Event *event, TAO_Notify_ProxySupplier *proxy_supplier, bool filtering)
 Constuct from event.

 TAO_Notify_Method_Request_Dispatch (const TAO_Notify::Delivery_Request_Ptr &delivery, TAO_Notify_ProxySupplier *proxy_supplier, bool filtering)
 Construct from a delivery rquest.

 TAO_Notify_Method_Request_Dispatch (const TAO_Notify_Method_Request_Event &request, const TAO_Notify_Event *event, TAO_Notify_ProxySupplier *proxy_supplier, bool filtering)
virtual ~TAO_Notify_Method_Request_Dispatch ()
 Destructor.


Static Public Member Functions

TAO_Notify_Method_Request_Dispatch_Queueable * unmarshal (TAO_Notify::Delivery_Request_Ptr &delivery_request, TAO_Notify_EventChannelFactory &ecf, TAO_InputCDR &cdr)
 Static method used to reconstruct a Method Request Dispatch.


Protected Member Functions

int execute_i (void)
 Execute the dispatch operation.


Protected Attributes

TAO_Notify_ProxySupplier::Ptr proxy_supplier_
 The Proxy.

bool filtering_
 Flag is true if we want to do filtering else false.

Member Enumeration Documentation

anonymous enum
 

an arbitrary code (Octet) to identify this delivery method type in persistent storage

Enumeration values:
persistence_code 

Definition at line 44 of file Method_Request_Dispatch.h. 

00044 {persistence_code = 1};

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Notify_Method_Request_Dispatch::TAO_Notify_Method_Request_Dispatch (  const TAO_Notify_Event *  event,
TAO_Notify_ProxySupplier *  proxy_supplier,
bool  filtering
) 
 

Constuct from event.

Definition at line 25 of file Method_Request_Dispatch.cpp. 

00029   : TAO_Notify_Method_Request_Event (event)
00030   , proxy_supplier_ (proxy_supplier)
00031   , filtering_ (filtering)
00032 {
00033 }

TAO_Notify_Method_Request_Dispatch::TAO_Notify_Method_Request_Dispatch (  const TAO_Notify::Delivery_Request_Ptr &  delivery,
TAO_Notify_ProxySupplier *  proxy_supplier,
bool  filtering
) 
 

Construct from a delivery rquest.

Definition at line 36 of file Method_Request_Dispatch.cpp.

References TAO_Notify::Delivery_Request_Ptr. 

00040   : TAO_Notify_Method_Request_Event (delivery)
00041   , proxy_supplier_ (proxy_supplier)
00042   , filtering_ (filtering)
00043 {
00044 }

TAO_Notify_Method_Request_Dispatch::TAO_Notify_Method_Request_Dispatch (  const TAO_Notify_Method_Request_Event &  request,
const TAO_Notify_Event *  event,
TAO_Notify_ProxySupplier *  proxy_supplier,
bool  filtering
) 
 

Constuct from another method request+event event is passed separately because we may be using a copy of the one in the previous method request

Definition at line 49 of file Method_Request_Dispatch.cpp. 

00054   : TAO_Notify_Method_Request_Event (request, event)
00055   , proxy_supplier_ (proxy_supplier)
00056   , filtering_ (filtering)
00057 {
00058 }

TAO_Notify_Method_Request_Dispatch::~TAO_Notify_Method_Request_Dispatch (   )  [virtual]
 

Destructor.

Definition at line 60 of file Method_Request_Dispatch.cpp.

References ACE_DEBUG, ACE_TEXT(), and LM_DEBUG. 

00061 {
00062 #if 0
00063   ACE_DEBUG ((LM_DEBUG,
00064               ACE_TEXT ("(%P|%t) Destroy TAO_Notify_Method_Request_Dispatch @%@\n"),
00065               this));
00066 #endif
00067 }

Member Function Documentation

int TAO_Notify_Method_Request_Dispatch::execute_i (  void   )  [protected]
 

Execute the dispatch operation.

Definition at line 69 of file Method_Request_Dispatch.cpp.

References ACE_DEBUG, ACE_TEXT(), TAO_Notify_Consumer::deliver(), TAO_Notify_Admin::filter_admin(), TAO_Notify_Admin::filter_operator(), filtering_, LM_DEBUG, proxy_supplier_, and TAO_debug_level.

Referenced by TAO_Notify_Method_Request_Dispatch_No_Copy::execute(), and TAO_Notify_Method_Request_Dispatch_Queueable::execute(). 

00070 {
00071   if (this->proxy_supplier_->has_shutdown ())
00072     return 0; // If we were shutdown while waiting in the queue, return with no action.
00073 
00074   if (this->filtering_ == 1)
00075     {
00076       TAO_Notify_Admin& parent = this->proxy_supplier_->consumer_admin ();
00077       CORBA::Boolean val =  this->proxy_supplier_->check_filters (this->event_,
00078                                                                   parent.filter_admin (),
00079                                                                   parent.filter_operator ());
00080 
00081       if (TAO_debug_level > 1)
00082         ACE_DEBUG ((LM_DEBUG, "Proxysupplier %x filter eval result = %d",&this->proxy_supplier_ , val));
00083 
00084       // Filter failed - do nothing.
00085       if (val == 0)
00086         return 0;
00087     }
00088 
00089   try
00090     {
00091       TAO_Notify_Consumer* consumer = this->proxy_supplier_->consumer ();
00092 
00093       if (consumer != 0)
00094         {
00095           consumer->deliver (this);
00096         }
00097     }
00098   catch (const CORBA::Exception& ex)
00099     {
00100       if (TAO_debug_level > 0)
00101         ex._tao_print_exception (
00102           ACE_TEXT (
00103             "TAO_Notify_Method_Request_Dispatch::: error sending event.\n "));
00104     }
00105 
00106   return 0;
00107 }

TAO_Notify_Method_Request_Dispatch_Queueable * TAO_Notify_Method_Request_Dispatch::unmarshal (  TAO_Notify::Delivery_Request_Ptr &  delivery_request,
TAO_Notify_EventChannelFactory &  ecf,
TAO_InputCDR &  cdr
)  [static]
 

Static method used to reconstruct a Method Request Dispatch.

Definition at line 111 of file Method_Request_Dispatch.cpp.

References ACE_CString, ACE_DEBUG, ACE_ERROR, ACE_NEW_NORETURN, ACE_TEXT(), DEBUG_LEVEL, TAO_Notify::Delivery_Request_Ptr, TAO_Notify_EventChannelFactory::find_proxy_consumer(), TAO_Notify_EventChannelFactory::find_proxy_supplier(), TAO_Notify_Object::ID, TAO_Notify::IdVec, LM_DEBUG, LM_ERROR, ACE_Vector< T, DEFAULT_SIZE >::push_back(), ACE_InputCDR::read_long(), ACE_InputCDR::read_ulong(), and ACE_OS::snprintf().

Referenced by TAO_Notify::Routing_Slip::unmarshal(). 

00115 {
00116   bool ok = true;
00117   TAO_Notify_Method_Request_Dispatch_Queueable * result = 0;
00118   ACE_CString textpath;
00119   CORBA::ULong count;
00120   if (cdr.read_ulong (count))
00121   {
00122     TAO_Notify::IdVec id_path (count);
00123     for (size_t nid = 0; ok && nid < count; ++nid)
00124     {
00125       TAO_Notify_Object::ID id = 0;
00126       if ( cdr.read_long (id))
00127       {
00128         id_path.push_back (id);
00129         char idbuf[20];
00130         ACE_OS::snprintf (idbuf, sizeof(idbuf), "/%d", static_cast<int> (id));
00131         textpath += idbuf;
00132       }
00133       else
00134       {
00135         ok = false;
00136       }
00137     }
00138 
00139     if (ok)
00140     {
00141       TAO_Notify_ProxySupplier* proxy_supplier = ecf.find_proxy_supplier (id_path,
00142         0);
00143       if (proxy_supplier != 0)
00144       {
00145         if (DEBUG_LEVEL > 6) ACE_DEBUG ((LM_DEBUG,
00146           ACE_TEXT ("(%P|%t) TAO_Notify_Method_Request_Dispatch reload event for %s\n")
00147           , textpath.c_str()
00148           ));
00149         ACE_NEW_NORETURN (result,
00150           TAO_Notify_Method_Request_Dispatch_Queueable (delivery_request, proxy_supplier, true));
00151       }
00152       else
00153       {
00154         TAO_Notify_ProxyConsumer * proxy_consumer = ecf.find_proxy_consumer (id_path, 0); //@@todo
00155         if (proxy_consumer == 0)
00156         {
00157           ACE_ERROR ((LM_ERROR,
00158             ACE_TEXT ("(%P|%t) TAO_Notify_Method_Request_Dispatch::unmarshal: unknown proxy id %s\n")
00159             , textpath.c_str()
00160             ));
00161         }
00162         else
00163         {
00164           ACE_ERROR ((LM_ERROR,
00165             ACE_TEXT ("(%P|%t) TAO_Notify_Method_Request_Dispatch::unmarshal: wrong type of proxy id %s\n")
00166             , textpath.c_str()
00167             ));
00168         }
00169       }
00170     }
00171     else
00172     {
00173       ACE_ERROR ((LM_ERROR,
00174         ACE_TEXT ("(%P|%t) TAO_Notify_Method_Request_Dispatch::unmarshal: Cant read proxy id path\n")
00175         ));
00176     }
00177   }
00178   return result;
00179 }

Member Data Documentation

bool TAO_Notify_Method_Request_Dispatch::filtering_ [protected]
 

Flag is true if we want to do filtering else false.

Definition at line 87 of file Method_Request_Dispatch.h.

Referenced by execute_i().

TAO_Notify_ProxySupplier::Ptr TAO_Notify_Method_Request_Dispatch::proxy_supplier_ [protected]
 

The Proxy.

Definition at line 84 of file Method_Request_Dispatch.h.

Referenced by TAO_Notify_Method_Request_Dispatch_No_Copy::copy(), and execute_i().

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 15:49:22 2008 for TAO_CosNotification by doxygen 1.3.6