granicus.if.org Git - icinga2/blob - lib/base/object.h

   1 /******************************************************************************
   2  * Icinga 2                                                                   *
   3  * Copyright (C) 2012 Icinga Development Team (http://www.icinga.org/)        *
   4  *                                                                            *
   5  * This program is free software; you can redistribute it and/or              *
   6  * modify it under the terms of the GNU General Public License                *
   7  * as published by the Free Software Foundation; either version 2             *
   8  * of the License, or (at your option) any later version.                     *
   9  *                                                                            *
  10  * This program is distributed in the hope that it will be useful,            *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of             *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the              *
  13  * GNU General Public License for more details.                               *
  14  *                                                                            *
  15  * You should have received a copy of the GNU General Public License          *
  16  * along with this program; if not, write to the Free Software Foundation     *
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.             *
  18  ******************************************************************************/
  19
  20 #ifndef OBJECT_H
  21 #define OBJECT_H
  22
  23 namespace icinga
  24 {
  25
  26 class SharedPtrHolder;
  27
  28 /**
  29  * Base class for all heap-allocated objects. At least one of its methods
  30  * has to be virtual for RTTI to work.
  31  *
  32  * @ingroup base
  33  */
  34 class I2_BASE_API Object : public enable_shared_from_this<Object>
  35 {
  36 public:
  37         typedef shared_ptr<Object> Ptr;
  38         typedef weak_ptr<Object> WeakPtr;
  39
  40         Object(void);
  41         virtual ~Object(void);
  42
  43         /**
  44          * Holds a shared pointer and provides support for implicit upcasts.
  45          *
  46          * @ingroup base
  47          */
  48         class SharedPtrHolder
  49         {
  50         public:
  51                 /**
  52                  * Constructor for the SharedPtrHolder class.
  53                  *
  54                  * @param object The shared pointer that should be used to
  55                  *               construct this shared pointer holder.
  56                  */
  57                 explicit SharedPtrHolder(const Object::Ptr& object)
  58                         : m_Object(object)
  59                 { }
  60
  61                 /**
  62                  * Retrieves a shared pointer for the object that is associated
  63                  * this holder instance.
  64                  *
  65                  * @returns A shared pointer.
  66                  */
  67                 template<typename T>
  68                 operator shared_ptr<T>(void) const
  69                 {
  70 #ifdef _DEBUG
  71                         shared_ptr<T> other = dynamic_pointer_cast<T>(m_Object);
  72                         ASSERT(other);
  73 #else /* _DEBUG */
  74                         shared_ptr<T> other = static_pointer_cast<T>(m_Object);
  75 #endif /* _DEBUG */
  76
  77                         return other;
  78                 }
  79
  80                 /**
  81                  * Retrieves a weak pointer for the object that is associated
  82                  * with this holder instance.
  83                  *
  84                  * @returns A weak pointer.
  85                  */
  86                 template<typename T>
  87                 operator weak_ptr<T>(void) const
  88                 {
  89                         return static_cast<shared_ptr<T> >(*this);
  90                 }
  91
  92         private:
  93                 Object::Ptr m_Object; /**< The object that belongs to this
  94                                            holder instance */
  95         };
  96
  97 #ifdef _DEBUG
  98         bool OwnsLock(void) const;
  99 #endif /* _DEBUG */
 100
 101 protected:
 102         SharedPtrHolder GetSelf(void);
 103
 104 private:
 105         Object(const Object& other);
 106         Object& operator=(const Object& rhs);
 107
 108 #ifndef _DEBUG
 109         typedef boost::mutex MutexType;
 110 #else /* _DEBUG */
 111         typedef boost::recursive_mutex MutexType;
 112
 113         static boost::mutex m_DebugMutex;
 114         mutable bool m_Locked;
 115         mutable boost::thread::id m_LockOwner;
 116 #endif /* _DEBUG */
 117
 118         mutable MutexType m_Mutex;
 119
 120         friend struct ObjectLock;
 121 };
 122
 123 /**
 124  * Compares a weak pointer with a raw pointer.
 125  *
 126  * @ingroup base
 127  */
 128 template<class T>
 129 struct WeakPtrEqual
 130 {
 131 private:
 132         const void *m_Ref; /**< The object. */
 133
 134 public:
 135         /**
 136          * Constructor for the WeakPtrEqual class.
 137          *
 138          * @param ref The object that should be compared with the weak pointer.
 139          */
 140         WeakPtrEqual(const void *ref) : m_Ref(ref) { }
 141
 142         /**
 143          * Compares the two pointers.
 144          *
 145          * @param wref The weak pointer.
 146          * @returns true if the pointers point to the same object, false otherwise.
 147          */
 148         bool operator()(const weak_ptr<T>& wref) const
 149         {
 150                 return (wref.lock().get() == static_cast<const T *>(m_Ref));
 151         }
 152 };
 153
 154 }
 155
 156 #endif /* OBJECT_H */