-#ifndef __DALI_INTERNAL_OWNER_POINTER_H__
-#define __DALI_INTERNAL_OWNER_POINTER_H__
+#ifndef DALI_INTERNAL_OWNER_POINTER_H
+#define DALI_INTERNAL_OWNER_POINTER_H
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
*/
-// EXTERNAL INCLUDES
-#include <cstddef> // NULL
-
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
namespace Internal
{
-
-template < typename T >
+template<typename T>
class OwnerPointer
{
public:
/**
* Default constructor. Creates an OwnerPointer that does not own any object.
+ * @note This does not protect against two different OwnerPointers pointing to the same object.
+ * Both OwnerPointers will try to release the memory of the same object in that case which
+ * could lead to a crash.
*/
OwnerPointer()
+ : mObject(nullptr)
{
- mObject = NULL;
}
/**
* Constructor. Creates an OwnerPointer that owns the object.
* @param[in] object A pointer to a heap allocated object.
*/
- OwnerPointer( T* object )
+ OwnerPointer(T* object)
+ : mObject(object)
{
- mObject = object;
}
/**
* Copy constructor. Passes the ownership of a pointer to another.
* @param[in] other The pointer that gives away the ownership.
*/
- OwnerPointer( OwnerPointer& other )
+ OwnerPointer(const OwnerPointer& other)
+ : OwnerPointer(static_cast<OwnerPointer&&>(const_cast<OwnerPointer&>(other))) // Remove constness & cast to rvalue to use the move constructor
+ {
+ // other needs to be const for compiler to pick up this as copy constructor;
+ // though we are using this as move as there can only be one owner
+ }
+
+ /**
+ * Move constructor. Passes the ownership of a pointer to another.
+ * @param[in] other The pointer that gives away the ownership.
+ */
+ OwnerPointer(OwnerPointer&& other)
+ : mObject(nullptr)
{
- Init( other );
+ Swap(other);
}
/**
* Assignment operator. Passes the ownership of a pointer to another.
* @param[in] other The pointer that gives away the ownership.
*/
- OwnerPointer& operator=( OwnerPointer& other )
+ OwnerPointer& operator=(OwnerPointer& other)
{
- if( this != &other ) // no self-assignment
+ if(this != &other) // no self-assignment
{
- Reset();
- Init( other );
+ delete mObject;
+ mObject = other.mObject;
+ other.mObject = nullptr;
}
// return self
}
/**
+ * Move assignment operator. Passes the ownership of a pointer to another.
+ * @param[in] other The pointer that gives away the ownership.
+ */
+ OwnerPointer& operator=(OwnerPointer&& other)
+ {
+ // Reuse operator=
+ return operator=(other);
+ }
+
+ /**
* Assignment operator. Takes the ownership of the object.
* If it owns an object already, it will be deleted.
* @param[in] pointer A pointer to a heap allocated object.
*/
- OwnerPointer& operator=( T* pointer )
+ OwnerPointer& operator=(T* pointer)
{
- if( mObject != pointer )
+ if(mObject != pointer)
{
Reset();
mObject = pointer;
*/
T& operator*()
{
- DALI_ASSERT_DEBUG( mObject != NULL );
+ DALI_ASSERT_DEBUG(mObject);
return *mObject;
}
*/
T& operator*() const
{
- DALI_ASSERT_DEBUG( mObject != NULL );
+ DALI_ASSERT_DEBUG(mObject);
// Pointer semantics: A const pointer does not mean const data.
- return const_cast< T& >( *mObject );
+ return const_cast<T&>(*mObject);
}
/**
T* operator->() const
{
// Pointer semantics: A const pointer does not mean const data.
- return const_cast< T* >( mObject );
+ return const_cast<T*>(mObject);
}
/**
* Compare with a raw pointer.
* @return true if the raw pointer matches the one owned by this object.
*/
- bool operator==( const T* pointer )
+ bool operator==(const T* pointer)
{
- return ( mObject == pointer );
+ return (mObject == pointer);
}
/**
*/
void Reset()
{
- if ( mObject != NULL )
- {
- delete mObject;
- mObject = NULL;
- }
+ delete mObject;
+ mObject = nullptr;
}
/**
*/
T* Release()
{
- T* tmp = mObject;
- mObject = NULL;
+ T* tmp = mObject;
+ mObject = nullptr;
return tmp;
}
return mObject;
}
- // Handle comparisons - This is a variation of the safe bool idiom
-
/**
- * Pointer-to-member type. Objects can be implicitly converted to this for validity checks.
+ * Swap owned objects
+ * @param[in] other The pointer to swap the owned objects with.
*/
- typedef void (OwnerPointer::*BooleanType)() const;
-
- /**
- * Converts an object handle to a BooleanType.
- * This is useful for checking whether the handle is NULL.
- */
- operator BooleanType() const
+ void Swap(OwnerPointer& other)
{
- return (mObject != NULL) ? &OwnerPointer::ThisIsSaferThanReturningVoidStar : NULL;
+ if(this != &other)
+ {
+ T* tmp = mObject;
+ mObject = other.mObject;
+ other.mObject = tmp;
+ }
}
-private:
-
- /**
- * Used by the safe bool idiom.
- */
- void ThisIsSaferThanReturningVoidStar() const {}
-
-private:
+ // Handle comparisons
/**
- * Initialise this pointer from another one.
- * ownerPointer parameter looses ownership.
- * @param ownerPointer owner pointer
+ * Converts an object handle to a bool.
+ * This is useful for checking whether the handle is NULL.
*/
- void Init( OwnerPointer& ownerPointer )
+ explicit operator bool() const
{
- mObject = ownerPointer.mObject;
- ownerPointer.mObject = NULL;
+ return mObject != nullptr;
}
+private:
// data
T* mObject; ///< Raw pointer to the object
};
} // namespace Dali
-#endif //__DALI_INTERNAL_OWNER_POINTER_H__
+#endif // DALI_INTERNAL_OWNER_POINTER_H