-#ifndef __DALI_INTERNAL_OWNER_POINTER_H__
-#define __DALI_INTERNAL_OWNER_POINTER_H__
-
-//
-// Copyright (c) 2014 Samsung Electronics Co., Ltd.
-//
-// Licensed under the Flora License, Version 1.0 (the License);
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://floralicense.org/license/
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an AS IS BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
+#ifndef DALI_INTERNAL_OWNER_POINTER_H
+#define DALI_INTERNAL_OWNER_POINTER_H
+
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
// 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( nullptr )
{
- mObject = NULL;
}
/**
* @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 )
+ 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 );
}
/**
{
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.
*/
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;
}
* Returns a const pointer to the object owned.
* @return a const pointer to the object.
*/
- const T* Get()
+ const T* Get() const
{
return mObject;
}
+ /**
+ * Swap owned objects
+ * @param[in] other The pointer to swap the owned objects with.
+ */
+ void Swap( OwnerPointer& other )
+ {
+ 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:
*/
void ThisIsSaferThanReturningVoidStar() const {}
-private:
-
- /**
- * Initialise this pointer from another one.
- * ownerPointer parameter looses ownership.
- * @param ownerPointer owner pointer
- */
- void Init( OwnerPointer& ownerPointer )
- {
- mObject = ownerPointer.mObject;
- ownerPointer.mObject = NULL;
- }
-
// data
T* mObject; ///< Raw pointer to the object
};
} // namespace Dali
-#endif //__DALI_INTERNAL_OWNER_POINTER_H__
+#endif // DALI_INTERNAL_OWNER_POINTER_H