dep/ACE_wrappers/ace/Monitor_Point_Registry.cpp

   1 // $Id: Monitor_Point_Registry.cpp 81833 2008-06-04 14:44:53Z parsons $
   2
   3 #include "ace/Monitor_Point_Registry.h"
   4
   5 #if defined (ACE_HAS_MONITOR_FRAMEWORK) && (ACE_HAS_MONITOR_FRAMEWORK == 1)
   6
   7 #include "ace/Monitor_Base.h"
   8
   9 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  10
  11 namespace ACE
  12 {
  13   namespace Monitor_Control
  14   {
  15     Monitor_Point_Registry*
  16     Monitor_Point_Registry::instance (void)
  17     {
  18       return
  19         ACE_Singleton<Monitor_Point_Registry, ACE_SYNCH_MUTEX>::instance ();
  20     }
  21
  22     Monitor_Point_Registry::Monitor_Point_Registry (void)
  23       : constraint_id_ (0)
  24     {
  25     }
  26
  27     bool
  28     Monitor_Point_Registry::add (Monitor_Base* type)
  29     {
  30       if (type == 0)
  31         {
  32           ACE_ERROR_RETURN ((LM_ERROR,
  33                              "registry add: null type\n"),
  34                             false);
  35         }
  36
  37       int status = 0;
  38
  39       {
  40         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, false);
  41
  42         type->add_ref ();
  43
  44         status = this->map_.bind (type->name (), type);
  45
  46         /// Temporary debugging code.
  47 //        ACE_DEBUG ((LM_DEBUG, "adding %s\n", type->name ()));
  48       }
  49
  50       if (status == -1)
  51         {
  52           ACE_ERROR_RETURN ((LM_ERROR,
  53                              "registry add: map bind failed\n"),
  54                             false);
  55         }
  56
  57       return (status == 0);
  58     }
  59
  60     bool
  61     Monitor_Point_Registry::remove (const char* name)
  62     {
  63       if (name == 0)
  64         {
  65           ACE_ERROR_RETURN ((LM_ERROR,
  66                              "registry remove: null name\n"),
  67                             false);
  68         }
  69
  70       int status = 0;
  71       Map::data_type mp = 0;
  72
  73       {
  74         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, false);
  75
  76         ACE_CString name_str (name, 0, false);
  77         status = this->map_.unbind (name_str, mp);
  78
  79         /// Temporary debugging code.
  80 //        ACE_DEBUG ((LM_DEBUG, "removing %s\n", name_str.c_str ()));
  81       }
  82
  83       if (status == -1)
  84         {
  85 // (JP) There is a problem with this failing on a single ACE_Message_Queue
  86 //      monitor per process. I think it is the message queue associated
  87 //      with the default reactor, maybe because at that low level, ACE
  88 //      is using malloc with placement, then free, which may bypass the
  89 //      normal destructors. In any case, it happens only at shutdown
  90 //      and there seems to be no memory leak.
  91 //          ACE_ERROR_RETURN ((LM_ERROR,
  92 //                             "registry remove: unbind failed for %s\n",
  93 //                             name),
  94 //                            false);
  95         }
  96       else
  97         {
  98           mp->remove_ref ();
  99         }
 100
 101       return (status == 0);
 102     }
 103
 104     Monitor_Control_Types::NameList
 105     Monitor_Point_Registry::names (void)
 106     {
 107       Monitor_Control_Types::NameList name_holder_;
 108
 109       {
 110         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0);
 111
 112         for (Map::CONST_ITERATOR i (this->map_); !i.done (); i.advance ())
 113           {
 114             name_holder_.push_back (i->key ());
 115           }
 116       }
 117
 118       return name_holder_;
 119     }
 120
 121     Monitor_Base*
 122     Monitor_Point_Registry::get (const ACE_CString& name) const
 123     {
 124       Map::data_type mp = 0;
 125
 126       {
 127         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0);
 128
 129         this->map_.find (name, mp);
 130       }
 131
 132       if (mp != 0)
 133         {
 134           mp->add_ref ();
 135         }
 136
 137       return mp;
 138     }
 139
 140     long
 141     Monitor_Point_Registry::constraint_id (void)
 142     {
 143       long retval = 0;
 144
 145       {
 146         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, -1);
 147
 148         retval = this->constraint_id_++;
 149       }
 150
 151       return retval;
 152     }
 153
 154     void
 155     Monitor_Point_Registry::cleanup (void)
 156     {
 157       for (Map::ITERATOR i = this->map_.begin ();
 158            i != this->map_.end ();
 159            i.advance ())
 160         {
 161           Map::ENTRY* entry = 0;
 162           i.next (entry);
 163           entry->int_id_->remove_ref ();
 164         }
 165     }
 166   }
 167 }
 168
 169 ACE_END_VERSIONED_NAMESPACE_DECL
 170
 171 #endif /* ACE_HAS_MONITOR_FRAMEWORK==1 */
 172