TAO/tao/Transport_Selection_Guard.h

   1 // -*- C++ -*-
   2
   3 // ===================================================================
   4 /**
   5  *  @file   Transport_Selection_Guard.h
   6  *
   7  *  @author Iliyan Jeliazkov <iliyan@ociweb.com>
   8  */
   9 // ===================================================================
  10
  11 #ifndef TAO_TRANSPORT_SELECTION_GUARD_H
  12 #define TAO_TRANSPORT_SELECTION_GUARD_H
  13
  14 #include /**/ "ace/pre.h"
  15
  16 #include "tao/TAO_Export.h"
  17
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 #include "tao/orbconf.h"
  23
  24 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  25
  26 // Forward declarations
  27 class TAO_Transport;
  28 class TAO_ORB_Core;
  29
  30 namespace TAO
  31 {
  32   /**
  33    * @class Transport_Selection_Guard
  34    *
  35    * @brief Used by the Transport Current feature to keep track of
  36    * which Transport is currently active.
  37    *
  38    * Whenever a Transport is selected: during an upcall, or prior to a
  39    * client invocation an instance of this class is created [on the
  40    * stack, or as a member of another class] to keep track of the said
  41    * Transport.  The class implements the RAII idiom, which makes it
  42    * possible to build a stack of these instances as the thread is
  43    * doing nested upcalls or client invocations.
  44    *
  45    * It utilizes TAO_TSS_Resources::tsg_ member pointer to keep track
  46    * of stack-linked Transport_Selection_Guard instances.
  47    *
  48    * If the Transport Current feature is disabled most methods are
  49    * no-ops and add no overhead on the critical path.
  50    *
  51    * <B>See Also:</B>
  52    *
  53    * https://htmlpreview.github.io/?https://github.com/DOCGroup/ACE_TAO/blob/master/TAO/docs/transport_current/index.html
  54    *
  55    */
  56   class TAO_Export Transport_Selection_Guard
  57   {
  58   public:
  59     static Transport_Selection_Guard* current (TAO_ORB_Core* core,
  60                                                size_t tss_slot_id);
  61
  62   public:
  63     /// Ctor
  64     Transport_Selection_Guard (TAO_Transport* t);
  65
  66     /// Dtor
  67     ~Transport_Selection_Guard ();
  68
  69     /// getter
  70     TAO_Transport* operator-> () const
  71     {
  72       return this->get ();
  73     }
  74
  75     /// getter
  76     TAO_Transport& operator* () const
  77     {
  78       return *this->get ();
  79     }
  80
  81     /// Getter
  82     TAO_Transport* get () const
  83     {
  84       return this->curr_;
  85     }
  86
  87     /// Setter
  88     Transport_Selection_Guard& set (TAO_Transport* t)
  89     {
  90       this->curr_ = t;
  91       return *this;
  92     }
  93
  94   Transport_Selection_Guard& operator=(const Transport_Selection_Guard& rhs) {
  95     if (this != &rhs)
  96       {
  97 #if TAO_HAS_TRANSPORT_CURRENT == 1
  98         prev_ = rhs.prev_;
  99 #endif  /* TAO_HAS_TRANSPORT_CURRENT == 1 */
 100         curr_ = rhs.curr_;
 101       }
 102     return *this;
 103   }
 104
 105   private:
 106     Transport_Selection_Guard (const Transport_Selection_Guard&) = delete;
 107
 108 #if TAO_HAS_TRANSPORT_CURRENT == 1
 109     /// This is pointing to the guard that was active prior to
 110     /// instantiating us.
 111     Transport_Selection_Guard* prev_;
 112
 113 #endif  /* TAO_HAS_TRANSPORT_CURRENT == 1 */
 114
 115     /// The "real" Transport, i.e. the one selected at present
 116     TAO_Transport* curr_;
 117
 118     friend TAO_Export bool
 119     operator== (const Transport_Selection_Guard& lhs,
 120                 const TAO_Transport* rhs);
 121
 122     friend TAO_Export bool
 123     operator== (const TAO_Transport* lhs,
 124                 const Transport_Selection_Guard& rhs);
 125
 126     friend TAO_Export bool
 127     operator!= (const Transport_Selection_Guard& lhs,
 128                 const TAO_Transport* rhs);
 129
 130     friend TAO_Export bool
 131     operator!= (const TAO_Transport* lhs,
 132                 const Transport_Selection_Guard& rhs);
 133
 134     template <class U> inline friend bool
 135     operator== (const Transport_Selection_Guard& lhs,
 136                 const U* rhs)
 137     {
 138       return lhs.curr_ == rhs;
 139     }
 140
 141     template <class U> inline friend bool
 142     operator== (const U* lhs,
 143                 const Transport_Selection_Guard& rhs)
 144     {
 145       return lhs == rhs.curr_;
 146     }
 147
 148     template <class U> inline friend bool
 149     operator!= (const Transport_Selection_Guard& lhs,
 150                 const U* rhs)
 151     {
 152       return lhs.curr_ != rhs;
 153     }
 154
 155     template <class U> inline friend bool
 156     operator!= (const U* lhs,
 157                 const Transport_Selection_Guard& rhs)
 158     {
 159       return lhs != rhs.curr_;
 160     }
 161   };
 162
 163   TAO_Export bool
 164   operator== (const Transport_Selection_Guard& lhs,
 165               const TAO_Transport* rhs);
 166
 167   TAO_Export bool
 168   operator== (const TAO_Transport* lhs,
 169               const Transport_Selection_Guard& rhs);
 170
 171   TAO_Export bool
 172   operator!= (const Transport_Selection_Guard& lhs,
 173               const TAO_Transport* rhs);
 174
 175   TAO_Export bool
 176   operator!= (const TAO_Transport* lhs,
 177               const Transport_Selection_Guard& rhs);
 178 } /* namespace TAO */
 179
 180 TAO_END_VERSIONED_NAMESPACE_DECL
 181
 182 #include /**/ "ace/post.h"
 183
 184 #endif /* TAO_TRANSPORT_SELECTION_GUARD_H */