-#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) 2019 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 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(NULL)
+ : mObject( nullptr )
{
}
* @param[in] object A pointer to a heap allocated 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 )
- : mObject(NULL)
+ 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 )
{
Swap( other );
}
{
if( this != &other ) // no self-assignment
{
- // Creation of temportaty object to prevent premature deletion of object
- OwnerPointer(other).Swap(*this);
+ 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.
*/
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 );
*/
void Reset()
{
- if ( mObject != NULL )
- {
- delete mObject;
- mObject = NULL;
- }
+ delete mObject;
+ mObject = nullptr;
}
/**
T* Release()
{
T* tmp = mObject;
- mObject = NULL;
+ mObject = nullptr;
return tmp;
}
/**
* Swap owned objects
+ * @param[in] other The pointer to swap the owned objects with.
*/
void Swap( OwnerPointer& other )
{
- T* tmp = mObject;
- mObject = other.mObject;
- other.mObject = tmp;
+ if( this != &other )
+ {
+ T* tmp = mObject;
+ mObject = other.mObject;
+ other.mObject = tmp;
+ }
}
// Handle comparisons - This is a variation of the safe bool idiom
*/
operator BooleanType() const
{
- return (mObject != NULL) ? &OwnerPointer::ThisIsSaferThanReturningVoidStar : NULL;
+ return ( mObject != nullptr ) ? &OwnerPointer::ThisIsSaferThanReturningVoidStar : nullptr;
}
private:
} // namespace Dali
-#endif //__DALI_INTERNAL_OWNER_POINTER_H__
+#endif // DALI_INTERNAL_OWNER_POINTER_H