TAO/tao/ORB_Table.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file     ORB_Table.h
   6  *
   7  *  @author Ossama Othman
   8  *  @author Carlos O'Ryan
   9  */
  10 //=============================================================================
  11
  12
  13 #ifndef TAO_ORB_TABLE_H
  14 #define TAO_ORB_TABLE_H
  15
  16 #include /**/ "ace/pre.h"
  17
  18 #include /**/ "tao/TAO_Export.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 #include "tao/orbconf.h"
  25 #include "tao/CORBA_String.h"
  26
  27 #include "ace/Array_Map.h"
  28 #include "ace/Thread_Mutex.h"
  29
  30
  31 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  32
  33 // Forward declarations.
  34 class TAO_ORB_Core;
  35
  36 namespace TAO
  37 {
  38   class ORB_Core_Ref_Counter;
  39
  40   /**
  41    * @class ORB_Table
  42    *
  43    * @brief Keep a table with all the ORBs in the system.
  44    *
  45    * CORBA::ORB_init() is supposed to return the same ORB if the
  46    * user specifies the same ORBid, either in the ORB_init()
  47    * parameter or in the -ORBid option.
  48    * This class is used to implement that feature.
  49    * It is also useful when trying to determine if an object
  50    * reference is collocated or not.
  51    *
  52    * @note This class should be instantiated via its instance()
  53    *       method.  Normally this would be enforced by making the
  54    *       constructor protected but that forces a friend declaration
  55    *       containing a template type (TAO_Singleton) with a static
  56    *       member to be introduced.  In turn, this potentially
  57    *       introduces problems in MS Windows DLL environments due to
  58    *       the occurrence of multiple singleton instances.  There
  59    *       should only be one!
  60    */
  61   class TAO_Export ORB_Table
  62   {
  63   public:
  64
  65     /// Constructor
  66     /**
  67      * @note See the note in the class description for an explanation
  68      *       of why this constructor is not protected.
  69      */
  70     ORB_Table ();
  71
  72     typedef ACE_Array_Map<CORBA::String_var,
  73                           ORB_Core_Ref_Counter,
  74                           TAO::String_Var_Equal_To> Table;
  75     typedef Table::key_type   key_type;
  76     typedef Table::data_type  data_type;
  77     typedef Table::value_type value_type;
  78     typedef Table::size_type  size_type;
  79     typedef Table::iterator   iterator;
  80
  81     /**
  82      * @name The canonical ACE_Map methods.
  83      */
  84     //@{
  85     iterator begin ();
  86     iterator end ();
  87     int bind (const char *orb_id, ::TAO_ORB_Core *orb_core);
  88
  89     /// Return @c TAO_ORB_Core corresponding to ORB with given @a
  90     /// orb_id.
  91     /**
  92      * @note The caller must decrease the reference count on the
  93      *       returned ORB_Core, i.e. the callers "owns" it.
  94      */
  95     ::TAO_ORB_Core* find (const char *orb_id);
  96
  97     int unbind (const char *orb_id);
  98     //@}
  99
 100     /// Obtain the first ORB for the @c ORB_Core_instance()
 101     /// implementation.
 102     ::TAO_ORB_Core * first_orb ();
 103
 104     /// Return a unique instance
 105     static ORB_Table * instance ();
 106
 107     /// Set the ORB related to the orb_id as the default ORB and not the
 108     /// ORB that is first binded.
 109     void set_default (char const * orb_id);
 110
 111     /// Method the ORB invokes to specify that it doesnt want to be the
 112     /// default ORB if there are more than one ORB registered.
 113     void not_default (char const * orb_id);
 114
 115     /// Accessor to the underlying table_
 116     Table * table ();
 117
 118     /// Return reference to underlying lock.
 119     TAO_SYNCH_MUTEX & lock ();
 120
 121   private:
 122
 123     // Prevent copying
 124     ORB_Table (const ORB_Table &);
 125     void operator= (const ORB_Table &);
 126
 127     /// Return @c TAO_ORB_Core corresponding to ORB with given @a
 128     /// orb_id.  (underlying unlocked implementation).
 129     ::TAO_ORB_Core * find_i (char const * orb_id);
 130
 131   private:
 132
 133     /// Lock used to synchronize access to the internal state.
 134     ::TAO_SYNCH_MUTEX lock_;
 135
 136     /// Variable to check if the first ORB decides not to be the
 137     /// default.
 138     bool first_orb_not_default_;
 139
 140     /// The underlying table.
 141     Table table_;
 142
 143     /// The first ORB created by the user
 144     ::TAO_ORB_Core * first_orb_;
 145   };
 146
 147   // -----------------------------------------------
 148
 149   /**
 150    * @class ORB_Table_Ref_Counter
 151    *
 152    * @brief Class contained by ORB_Table's Unbounded_Set.
 153    *
 154    * Class contained by ORB_Table's Unbounded_Set.
 155    */
 156   class ORB_Core_Ref_Counter
 157   {
 158   public:
 159
 160     /// Constructor.
 161     ORB_Core_Ref_Counter ();
 162
 163     /// Constructor.
 164     ORB_Core_Ref_Counter (::TAO_ORB_Core * core);
 165
 166     /// Destructor.
 167     ~ORB_Core_Ref_Counter ();
 168
 169     /// Copy constructor.
 170     ORB_Core_Ref_Counter (ORB_Core_Ref_Counter const & rhs);
 171
 172     /// Assignment operator.
 173     void operator= (ORB_Core_Ref_Counter const & rhs);
 174
 175     /// ORB_Core pointer accessor.
 176     ::TAO_ORB_Core * core () const { return this->core_; }
 177
 178   private:
 179     ::TAO_ORB_Core * core_;
 180   };
 181
 182 }
 183
 184 TAO_END_VERSIONED_NAMESPACE_DECL
 185
 186 #if defined (__ACE_INLINE__)
 187 # include "tao/ORB_Table.inl"
 188 #endif /* __ACE_INLINE__ */
 189
 190 #include /**/ "ace/post.h"
 191
 192 #endif  /* TAO_ORB_TABLE_H */