dali/internal/common/owner-pointer.h

   1 #ifndef __DALI_INTERNAL_OWNER_POINTER_H__
   2 #define __DALI_INTERNAL_OWNER_POINTER_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstddef>    // NULL
  23
  24 // INTERNAL INCLUDES
  25 #include <dali/public-api/common/dali-common.h>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Internal
  31 {
  32
  33 template < typename T >
  34 class OwnerPointer
  35 {
  36 public:
  37   /**
  38    * Default constructor. Creates an OwnerPointer that does not own any object.
  39    */
  40   OwnerPointer()
  41   {
  42     mObject = NULL;
  43   }
  44
  45   /**
  46    * Constructor. Creates an OwnerPointer that owns the object.
  47    * @param[in] object A pointer to a heap allocated object.
  48    */
  49   OwnerPointer( T* object )
  50   {
  51     mObject = object;
  52   }
  53
  54   /**
  55    * Copy constructor. Passes the ownership of a pointer to another.
  56    * @param[in] other The pointer that gives away the ownership.
  57    */
  58   OwnerPointer( OwnerPointer& other )
  59   {
  60     Init( other );
  61   }
  62
  63   /**
  64    * Assignment operator. Passes the ownership of a pointer to another.
  65    * @param[in] other The pointer that gives away the ownership.
  66    */
  67   OwnerPointer& operator=( OwnerPointer& other )
  68   {
  69     if( this != &other )    // no self-assignment
  70     {
  71       Reset();
  72       Init( other );
  73     }
  74
  75     // return self
  76     return *this;
  77   }
  78
  79   /**
  80    * Assignment operator. Takes the ownership of the object.
  81    * If it owns an object already, it will be deleted.
  82    * @param[in] pointer A pointer to a heap allocated object.
  83    */
  84   OwnerPointer& operator=( T* pointer )
  85   {
  86     if( mObject != pointer )
  87     {
  88       Reset();
  89       mObject = pointer;
  90     }
  91
  92     return *this;
  93   }
  94
  95   /**
  96    * Destructor.
  97    */
  98   ~OwnerPointer()
  99   {
 100     Reset();
 101   }
 102
 103   /**
 104    * Indirection operator.
 105    * @return a reference to the object.
 106    */
 107   T& operator*()
 108   {
 109     DALI_ASSERT_DEBUG( mObject != NULL );
 110
 111     return *mObject;
 112   }
 113
 114   /**
 115    * Const indirection operator.
 116    * @return a reference to the object from const OwnerPointer.
 117    */
 118   T& operator*() const
 119   {
 120     DALI_ASSERT_DEBUG( mObject != NULL );
 121
 122     // Pointer semantics: A const pointer does not mean const data.
 123     return const_cast< T& >( *mObject );
 124   }
 125
 126   /**
 127    * Pointer operator.
 128    * @return a pointer to the object.
 129    */
 130   T* operator->()
 131   {
 132     return mObject;
 133   }
 134
 135   /**
 136    * Const pointer operator.
 137    * @return a pointer to the object referenced by a const OwnerPointer.
 138    */
 139   T* operator->() const
 140   {
 141     // Pointer semantics: A const pointer does not mean const data.
 142     return const_cast< T* >( mObject );
 143   }
 144
 145   /**
 146    * Compare with a raw pointer.
 147    * @return true if the raw pointer matches the one owned by this object.
 148    */
 149   bool operator==( const T* pointer )
 150   {
 151     return ( mObject == pointer );
 152   }
 153
 154   /**
 155    * Reset the pointer, deleting any owned object.
 156    */
 157   void Reset()
 158   {
 159     if ( mObject != NULL )
 160     {
 161       delete mObject;
 162       mObject = NULL;
 163     }
 164   }
 165
 166   /**
 167    * Release the ownership, it does not delete the object.
 168    * @return a pointer to the object.
 169    */
 170   T* Release()
 171   {
 172     T* tmp = mObject;
 173     mObject = NULL;
 174     return tmp;
 175   }
 176
 177   /**
 178    * Returns a const pointer to the object owned.
 179    * @return a const pointer to the object.
 180    */
 181   const T* Get() const
 182   {
 183     return mObject;
 184   }
 185
 186   // Handle comparisons - This is a variation of the safe bool idiom
 187
 188   /**
 189    * Pointer-to-member type. Objects can be implicitly converted to this for validity checks.
 190    */
 191   typedef void (OwnerPointer::*BooleanType)() const;
 192
 193   /**
 194    * Converts an object handle to a BooleanType.
 195    * This is useful for checking whether the handle is NULL.
 196    */
 197   operator BooleanType() const
 198   {
 199     return (mObject != NULL) ? &OwnerPointer::ThisIsSaferThanReturningVoidStar : NULL;
 200   }
 201
 202 private:
 203
 204   /**
 205    * Used by the safe bool idiom.
 206    */
 207   void ThisIsSaferThanReturningVoidStar() const {}
 208
 209 private:
 210
 211   /**
 212    * Initialise this pointer from another one.
 213    * ownerPointer parameter looses ownership.
 214    * @param ownerPointer owner pointer
 215    */
 216   void Init( OwnerPointer& ownerPointer )
 217   {
 218     mObject = ownerPointer.mObject;
 219     ownerPointer.mObject = NULL;
 220   }
 221
 222   // data
 223   T* mObject; ///< Raw pointer to the object
 224 };
 225
 226 } // namespace Internal
 227
 228 } // namespace Dali
 229
 230 #endif //__DALI_INTERNAL_OWNER_POINTER_H__