TAO/tao/Asynch_Reply_Dispatcher_Base.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file Asynch_Reply_Dispatcher_Base.h
   6  *
   7  *  @author Alexander Babu Arulanthu <alex@cs.wustl.edu>
   8  *  @author Jeff Parsons <parsons@cs.wustl.edu>
   9  */
  10 //=============================================================================
  11
  12 #ifndef TAO_ASYNCH_REPLY_DISPATCHER_BASE_H
  13 #define TAO_ASYNCH_REPLY_DISPATCHER_BASE_H
  14
  15 #include /**/ "ace/pre.h"
  16
  17 #include "tao/Reply_Dispatcher.h"
  18 #include "tao/CDR.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 #include "tao/IOPC.h"
  25
  26 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  27 class ACE_Time_Value;
  28 class ACE_Lock;
  29 class ACE_Allocator;
  30 ACE_END_VERSIONED_NAMESPACE_DECL
  31
  32 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  33
  34 class TAO_Pluggable_Reply_Params;
  35 class TAO_ORB_Core;
  36 class TAO_Transport;
  37 /**
  38  * @class TAO_Asynch_Reply_Dispatcher_Base
  39  *
  40  * @brief Base class for TAO_Asynch_Reply_Dispatcher and
  41  *  TAO_DII_Deferred_Reply_Dispatcher
  42  */
  43 class TAO_Export TAO_Asynch_Reply_Dispatcher_Base
  44   : public TAO_Reply_Dispatcher
  45 {
  46 public:
  47   /// Default constructor.
  48   TAO_Asynch_Reply_Dispatcher_Base (TAO_ORB_Core *orb_core,
  49                                     ACE_Allocator *allocator = 0);
  50
  51   /// Sets the transport for this invocation.
  52   void transport (TAO_Transport *t);
  53
  54   /// Install the timeout handler
  55   virtual long schedule_timer (CORBA::ULong , const ACE_Time_Value &) = 0;
  56
  57
  58   /// A helper method that can be used by the subclasses
  59   /**
  60    * The semantics of this helper method needs careful attention. A
  61    * call to this method will do the following
  62    *
  63    *   - If the reply has already been dispatched, the return value
  64    *     will be false to signify not to try.
  65    *
  66    *   - If the reply has not been dispatched, this method will set
  67    *     the flag to be true and return a true value to signify that
  68    *     the caller thread can go ahead and dispatch reply.
  69    *
  70    * Why are we clumping everything in one method. Answer is we need
  71    * atomicity?
  72    */
  73   bool try_dispatch_reply ();
  74
  75 protected:
  76   /// Destructor.
  77   virtual ~TAO_Asynch_Reply_Dispatcher_Base ();
  78
  79 private:
  80   void operator= (const TAO_Asynch_Reply_Dispatcher_Base &);
  81   TAO_Asynch_Reply_Dispatcher_Base (const TAO_Asynch_Reply_Dispatcher_Base &);
  82
  83 protected:
  84   /// The service context list.
  85   /**
  86    * Note, that this is not a reference as in
  87    * the synchronous case. We own the reply_service_info
  88    * because our TAO_Asynch_Invocation or TAO_DII_Deferred_Invocation
  89    * will go out of scope before we are done.
  90    */
  91   IOP::ServiceContextList reply_service_info_;
  92
  93   /// The buffer that is used to initialise the data block
  94   char buf_[ACE_CDR::DEFAULT_BUFSIZE];
  95
  96   /// Datablock that is created on the stack to initialise the CDR
  97   /// stream underneath.
  98   ACE_Data_Block db_;
  99
 100   /// CDR stream which has the reply information that needs to be
 101   /// demarshalled by the stubs
 102   TAO_InputCDR reply_cdr_;
 103
 104   /// This invocation is using this transport, may change...
 105   TAO_Transport *transport_;
 106
 107 private:
 108   /// Lock to protect @c is_reply_dispatched_ flag.
 109   ACE_Lock *lock_;
 110
 111   /// Has the reply been dispatched?
 112   bool is_reply_dispatched_;
 113 };
 114
 115 namespace TAO
 116 {
 117   /**
 118    * @class ARDB_Refcount_Functor
 119    *
 120    * @brief Functor for refcounting of Asynch_Reply_Dispatcher_Base
 121    *
 122    * This is used to safely handle the destruction of
 123    * Asynch_Reply_Dispatcher_Base objects which are created on the
 124    * heap. We cannot use auto_ptr <> since it calls delete on the
 125    * pointer, and calling delete on Asynch_Reply_Dispatcher_Base *
 126    * will not work. Hence this functor will be used with Auto_Functor
 127    * class to handle the memory safely.
 128    *
 129    * @todo Ideally, this class can be a generic class. But that
 130    * requires quite a bit of cleanup within TAO to be more useful.
 131    */
 132   class TAO_Export ARDB_Refcount_Functor
 133   {
 134   public:
 135     void operator() (TAO_Asynch_Reply_Dispatcher_Base *ardb) noexcept;
 136   };
 137 }
 138
 139 TAO_END_VERSIONED_NAMESPACE_DECL
 140
 141 #if defined (__ACE_INLINE__)
 142 #include "tao/Asynch_Reply_Dispatcher_Base.inl"
 143 #endif /* __ACE_INLINE__ */
 144
 145 #include /**/ "ace/post.h"
 146 #endif /* TAO_ASYNCH_REPLY_DISPATCHER_BASE_H */