X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Fpublic-api%2Fcommon%2Fdali-vector.h;h=fd4565e9c539dcb8e72cc1714668d02daac01908;hb=eac64a03127943987803811b435314534a967f2c;hp=83a2df6c21bcb636fdca1750f67bcb23c0e3d693;hpb=423c5be7c4b4f6271f8c23dec6e51b2d3a44e0f6;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/public-api/common/dali-vector.h b/dali/public-api/common/dali-vector.h index 83a2df6..fd4565e 100644 --- a/dali/public-api/common/dali-vector.h +++ b/dali/public-api/common/dali-vector.h @@ -1,8 +1,8 @@ -#ifndef __DALI_VECTOR_H__ -#define __DALI_VECTOR_H__ +#ifndef DALI_VECTOR_H +#define DALI_VECTOR_H /* - * Copyright (c) 2015 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. @@ -19,29 +19,16 @@ */ // EXTERNAL INCLUDES -#include #include +#include +#include // uint32_t // INTERNAL INCLUDES #include #include #include -/** - * @brief For DALi internal use asserts are enabled in debug builds. - * - * For Application use asserts can be enabled manually. - * @SINCE_1_0.0 - */ -#if defined( DEBUG_ENABLED ) -#define ENABLE_VECTOR_ASSERTS -#endif - -#if defined( ENABLE_VECTOR_ASSERTS ) #define DALI_ASSERT_VECTOR(cond) DALI_ASSERT_ALWAYS(cond) -#else -#define DALI_ASSERT_VECTOR(cond) -#endif namespace Dali { @@ -58,14 +45,12 @@ namespace Dali * beginning of the first real item so that iterating the items is quick. * @SINCE_1_0.0 */ -class DALI_IMPORT_API VectorBase +class DALI_CORE_API VectorBase { public: // Typedefs - - typedef std::size_t SizeType; + using SizeType = std::size_t; protected: // Construction - /** * @brief Default constructor. Does not allocate space. * @SINCE_1_0.0 @@ -76,27 +61,26 @@ protected: // Construction * @brief Destructor. * * Does not release the space. Derived class needs to call Release. - * Not virtual as should not be called directly and we do not want + * Not virtual as this should not be called directly and we do not want * a vtable for this class as it would unnecessarily increase size. * @SINCE_1_0.0 */ ~VectorBase(); public: // API - /** - * @brief This method is inlined as its needed frequently for Vector::End() iterator. + * @brief This method is inlined as it's needed frequently for Vector::End() iterator. * * @SINCE_1_0.0 - * @return The count of elements in this vector. + * @return The count of elements in this vector */ SizeType Count() const { SizeType items = 0u; - if( mData ) + if(mData) { - SizeType* metadata = reinterpret_cast< SizeType* >( mData ); - items = *(metadata - 1u); + SizeType* metadata = reinterpret_cast(mData); + items = *(metadata - 1u); } return items; } @@ -104,7 +88,7 @@ public: // API /** * @brief Gets the count of elements in this vector. * @SINCE_1_0.0 - * @return The count of elements in this vector. + * @return The count of elements in this vector */ SizeType Size() const { @@ -112,9 +96,9 @@ public: // API } /** - * @brief @ return If the vector is empty + * @brief @ return if the vector is empty. * @SINCE_1_0.0 - * @return true if the count of elements is empty + * @return True if the count of elements is empty */ bool Empty() const { @@ -124,12 +108,12 @@ public: // API /** * @brief Gets the capacity of this vector. * @SINCE_1_0.0 - * @return The capacity of this vector. + * @return The capacity of this vector */ SizeType Capacity() const; /** - * @brief Release the data. + * @brief Releases the data. * * Does not call destructors on objects held. * @SINCE_1_0.0 @@ -137,63 +121,62 @@ public: // API void Release(); protected: // for Derived classes - /** * @brief Helper to set the count. * * @SINCE_1_0.0 - * @param[in] count Number of elements in the vector. + * @param[in] count Number of elements in the vector */ - void SetCount( SizeType count ); + void SetCount(SizeType count); /** - * @brief Reserve space in the vector. + * @brief Reserves space in the vector. * * @SINCE_1_0.0 - * @param[in] count Count of elements to reserve. - * @param[in] elementSize Size of a single element. + * @param[in] count Count of elements to reserve + * @param[in] elementSize Size of a single element */ - void Reserve( SizeType count, SizeType elementSize ); + void Reserve(SizeType count, SizeType elementSize); /** * @brief Copy a vector. * * @SINCE_1_0.0 - * @param[in] vector Vector to copy from. - * @param[in] elementSize Size of a single element. + * @param[in] vector Vector to copy from + * @param[in] elementSize Size of a single element */ - void Copy( const VectorBase& vector, SizeType elementSize ); + void Copy(const VectorBase& vector, SizeType elementSize); /** - * @brief Swap the contents of two vectors. + * @brief Swaps the contents of two vectors. * * @SINCE_1_0.0 - * @param[in] vector Vector to swap with. + * @param[in] vector Vector to swap with */ - void Swap( VectorBase& vector ); + void Swap(VectorBase& vector); /** - * @brief Erase an element. + * @brief Erases an element. * * Does not change capacity. * @SINCE_1_0.0 - * @param[in] address Adress to erase from. - * @param[in] elementSize Size to erase. + * @param[in] address Address to erase from + * @param[in] elementSize Size to erase * @pre Last element cannot be erased as there is nothing to move. */ - void Erase( char* address, SizeType elementSize ); + void Erase(char* address, SizeType elementSize); /** - * @brief Erase a range of elements. + * @brief Erases a range of elements. * * Does not change capacity. * @SINCE_1_0.0 - * @param[in] first Address to the first element to be erased. - * @param[in] last Address to the last element to be erased. - * @param[in] elementSize Size of one of the elements to be erased. - * @return Address pointing to the next element of the last one. + * @param[in] first Address to the first element to be erased + * @param[in] last Address to the last element to be erased + * @param[in] elementSize Size of one of the elements to be erased + * @return Address pointing to the next element of the last one */ - char* Erase( char* first, char* last, SizeType elementSize ); + char* Erase(char* first, char* last, SizeType elementSize); /** * @brief Copies a number of bytes from \e source to \e destination. @@ -201,63 +184,62 @@ protected: // for Derived classes * \e source and \e destination must not overlap. * * @SINCE_1_0.0 - * @param[in] destination Pointer to the destination address. - * @param[in] source Pointer to the source address. - * @param[in] numberOfBytes The number of bytes to be copied. + * @param[in] destination Pointer to the destination address + * @param[in] source Pointer to the source address + * @param[in] numberOfBytes The number of bytes to be copied */ - void CopyMemory( char* destination, const char* source, size_t numberOfBytes ); + void CopyMemory(char* destination, const char* source, size_t numberOfBytes); private: + // not copyable as it does not know the size of elements + VectorBase(const VectorBase&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0 + VectorBase& operator=(const VectorBase&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0 - // not copiable as it does not know the size of elements - VectorBase( const VectorBase& ); ///< Undefined @SINCE_1_0.0 - VectorBase& operator=( const VectorBase& ); ///< Undefined @SINCE_1_0.0 - -protected: // Data + // not movable as this is handled by deriving classes + VectorBase(VectorBase&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25 + VectorBase& operator=(VectorBase&&) = delete; ///< Deleted copy assignment operator. @SINCE_1_9.25 +protected: // Data void* mData; ///< Pointer to the data. - }; +/// @cond internal /** * @brief Vector algorithm variant for trivial types. * * Trivial types do not need destructor or copy constructor called. * @SINCE_1_0.0 */ -template< bool IsTrivial > +template class VectorAlgorithms : public VectorBase { protected: // API for deriving classes - - typedef VectorBase::SizeType SizeType; + using SizeType = VectorBase::SizeType; /** * @brief Empty constructor. * @SINCE_1_0.0 */ - VectorAlgorithms() - { } + VectorAlgorithms() = default; /** * @brief Empty destructor. * @SINCE_1_0.0 */ - ~VectorAlgorithms() - { } + ~VectorAlgorithms() = default; /** * @brief Copy vector contents. * * @SINCE_1_0.0 - * @param[in] rhs VectorBase object to copy from. - * @param[in] elementSize Size of the content. + * @param[in] rhs VectorBase object to copy from + * @param[in] elementSize Size of the content */ - void Copy( const VectorBase& rhs, SizeType elementSize ) + void Copy(const VectorBase& rhs, SizeType elementSize) { - if( rhs.Capacity() > 0u ) + if(rhs.Capacity() > 0u) { - VectorBase::Copy( rhs, elementSize ); + VectorBase::Copy(rhs, elementSize); } else { @@ -266,46 +248,46 @@ protected: // API for deriving classes } /** - * @brief Reserve space in the vector. + * @brief Reserves space in the vector. * * @SINCE_1_0.0 - * @param[in] count Count of elements to reserve. - * @param[in] elementSize Size of a single element. + * @param[in] count Count of elements to reserve + * @param[in] elementSize Size of a single element */ - void Reserve( SizeType count, SizeType elementSize ) + void Reserve(SizeType count, SizeType elementSize) { - VectorBase::Reserve( count, elementSize ); + VectorBase::Reserve(count, elementSize); } /** - * @brief Resize the vector. Does not change capacity. + * @brief Resizes the vector. Does not change capacity. * * @SINCE_1_0.0 - * @param[in] count Count to resize to. - * @param[in] elementSize Size of a single element. + * @param[in] count Count to resize to + * @param[in] elementSize Size of a single element */ - void Resize( SizeType count, SizeType elementSize ) + void Resize(SizeType count, SizeType elementSize) { // reserve will copy old elements as well - Reserve( count, elementSize ); + Reserve(count, elementSize); } /** - * @brief Clear the contents. + * @brief Clears the contents. * - * For simple types nothing to do. + * For simple types, nothing to do. * @SINCE_1_0.0 */ void Clear() { - if( mData ) + if(mData) { - VectorBase::SetCount( 0u ); + VectorBase::SetCount(0u); } } /** - * @brief Release the vector. + * @brief Releases the vector. * @SINCE_1_0.0 */ void Release() @@ -314,70 +296,72 @@ protected: // API for deriving classes } /** - * @brief Erase an element. Does not change capacity. + * @brief Erases an element. Does not change capacity. * * @SINCE_1_0.0 - * @param[in] address Address to erase from. - * @param[in] elementSize Size to erase. + * @param[in] address Address to erase from + * @param[in] elementSize Size to erase */ - void Erase( char* address, SizeType elementSize ) + void Erase(uint8_t* address, SizeType elementSize) { - VectorBase::Erase( address, elementSize ); + VectorBase::Erase(reinterpret_cast(address), elementSize); } /** - * @brief Erase a range of elements. Does not change capacity. + * @brief Erases a range of elements. Does not change capacity. * * @SINCE_1_0.0 - * @param[in] first Address to the first element to be erased. - * @param[in] last Address to the last element to be erased. - * @param[in] elementSize Size of one of the elements to be erased. - * @return Address pointing to the next element of the last one. + * @param[in] first Address to the first element to be erased + * @param[in] last Address to the last element to be erased + * @param[in] elementSize Size of one of the elements to be erased + * @return Address pointing to the next element of the last one */ - char* Erase( char* first, char* last, SizeType elementSize ) + uint8_t* Erase(uint8_t* first, uint8_t* last, SizeType elementSize) { - return VectorBase::Erase( first, last, elementSize ); + return reinterpret_cast(VectorBase::Erase(reinterpret_cast(first), reinterpret_cast(last), elementSize)); } /** * @brief Inserts the given elements into the vector. * * @SINCE_1_0.0 - * @param[in] at Address where to insert the elements into the vector. - * @param[in] from Address to the first element to be inserted. - * @param[in] to Address to the last element to be inserted. - * @param[in] elementSize Size of one of the elements to be inserted. + * @param[in] at Address where to insert the elements into the vector + * @param[in] from Address to the first element to be inserted + * @param[in] to Address to the last element to be inserted + * @param[in] elementSize Size of one of the elements to be inserted */ - void Insert( char* at, char* from, char* to, SizeType elementSize ) + void Insert(uint8_t* at, uint8_t* from, uint8_t* to, SizeType elementSize) { - const SizeType size = to - from; - const SizeType count = Count(); + const SizeType size = to - from; + const SizeType count = Count(); const SizeType newCount = count + size / elementSize; - if( newCount > Capacity() ) + if(newCount > Capacity()) { // Calculate the at offset as the pointer is invalid after the Reserve() call. - std::size_t offset = at - reinterpret_cast( mData ); + std::size_t offset = at - reinterpret_cast(mData); // need more space - Reserve( NextPowerOfTwo( newCount ), elementSize ); // reserve enough space to store at least the next power of two elements of the new required size. + Reserve(NextPowerOfTwo(static_cast(newCount)), elementSize); // reserve enough space to store at least the next power of two elements of the new required size. // Set the new at pointer. - at = reinterpret_cast( mData ) + offset; + at = reinterpret_cast(mData) + offset; } // set new count first as otherwise the debug assert will hit us - SetCount( newCount ); + SetCount(newCount); // Move current items to a new position inside the vector. - CopyMemory( at + size, - at, - ( reinterpret_cast( mData ) + count * elementSize ) - at ); + CopyMemory(reinterpret_cast(at + size), + reinterpret_cast(at), + (reinterpret_cast(mData) + count * elementSize) - at); // Copy the given items. - CopyMemory( at, from, size ); + CopyMemory(reinterpret_cast(at), reinterpret_cast(from), size); } }; +/// @endcond +/// @cond internal /** * @brief Vector algorithm variant for complex types. * @@ -387,46 +371,47 @@ protected: // API for deriving classes * @SINCE_1_0.0 */ template<> -class VectorAlgorithms< false > : public VectorBase +class VectorAlgorithms : public VectorBase { private: - VectorAlgorithms() - { } - ~VectorAlgorithms() - { } + VectorAlgorithms() = default; + ~VectorAlgorithms() = default; }; +/// @endcond /** - * @brief Vector class with minimum space allocation when its empty. + * @brief Vector class with minimum space allocation when it's empty. * * @SINCE_1_0.0 - * @param type of the data that the vector holds. + * @param type The type of the data that the vector holds */ -template< class T, bool IsTrivialType = TypeTraits::IS_TRIVIAL_TYPE == true > -class Vector : public VectorAlgorithms< IsTrivialType > +template::IS_TRIVIAL_TYPE == true> +class Vector : public VectorAlgorithms { public: // API - /** * @brief Type definitions. * @SINCE_1_0.0 */ - typedef VectorBase::SizeType SizeType; ///< Size type @SINCE_1_0.0 - typedef T* Iterator; ///< Most simple Iterator is a pointer @SINCE_1_0.0 - typedef const T* ConstIterator; ///< Const iterator @SINCE_1_0.0 - typedef T ItemType; ///< Item type @SINCE_1_0.0 + using SizeType = VectorBase::SizeType; ///< Size type @SINCE_1_0.0 + using Iterator = T*; ///< Most simple Iterator is a pointer @SINCE_1_0.0 + using ConstIterator = const T*; ///< Const iterator @SINCE_1_0.0 + using ItemType = T; ///< Item type @SINCE_1_0.0 + /** + * @brief Enumeration for BaseType. + * @SINCE_1_0.0 + */ enum { - BaseType = IsTrivialType + BaseType = IsTrivialType ///< @SINCE_1_0.0 }; /** * @brief Default constructor. Does not allocate any space. * @SINCE_1_0.0 */ - Vector() - { } + Vector() = default; /** * @brief Destructor. Releases the allocated space. @@ -441,26 +426,58 @@ public: // API * @brief Copy constructor. * * @SINCE_1_0.0 - * @param[in] vector Vector to copy from. + * @param[in] vector Vector to copy from + */ + Vector(const Vector& vector) + { + // reuse copy assignment + operator=(vector); + } + + /** + * @brief Default move constructor. + * + * @SINCE_1_9.25 + * @param[in] vector Vector to move */ - Vector( const Vector& vector ) + Vector(Vector&& vector) { - // reuse assignment - operator=( vector ); + // reuse move assignment + operator=(std::move(vector)); } /** * @brief Assignment operator. * * @SINCE_1_0.0 - * @param[in] vector Vector to assign from. - * @return Reference to self for chaining. + * @param[in] vector Vector to assign from + * @return Reference to self for chaining + */ + Vector& operator=(const Vector& vector) + { + if(this != &vector) + { + VectorAlgorithms::Copy(vector, sizeof(ItemType)); + } + return *this; + } + + /** + * @brief Default move assignment operator. + * + * @SINCE_1_9.25 + * @param[in] vector Vector to move */ - Vector& operator=( const Vector& vector ) + Vector& operator=(Vector&& vector) { - if( this != &vector ) + if(this != &vector) { - VectorAlgorithms::Copy( vector, sizeof( ItemType ) ); + if(VectorBase::mData) + { + Release(); + } + VectorBase::mData = vector.mData; + vector.mData = nullptr; } return *this; } @@ -468,82 +485,102 @@ public: // API /** * @brief Iterator to the beginning of the data. * @SINCE_1_0.0 - * @return Iterator to the beginning of the data. + * @return Iterator to the beginning of the data */ Iterator Begin() const { - ItemType* address = reinterpret_cast( VectorBase::mData ); + ItemType* address = reinterpret_cast(VectorBase::mData); return address; } /** * @brief Iterator to the end of the data (one past last element). * @SINCE_1_0.0 - * @return Iterator to the end of the data (one past last element). + * @return Iterator to the end of the data (one past last element) */ Iterator End() const { - ItemType* address = reinterpret_cast( VectorBase::mData ); + ItemType* address = reinterpret_cast(VectorBase::mData); address += VectorBase::Count(); return address; } /** + * Support for C++11 Range-based for loop: for( item : container ). + * @SINCE_1_2.60 + * @return The start iterator + */ + Iterator begin() const + { + return Begin(); + } + + /** + * Support for C++11 Range-based for loop: for( item : container ). + * @SINCE_1_2.60 + * @return The end iterator + */ + Iterator end() const + { + return End(); + } + + /** * @brief Subscript operator. * @SINCE_1_0.0 - * @param[in] index Index of the element. - * @return Reference to the element for given index. + * @param[in] index Index of the element + * @return Reference to the element for given index * @pre Index must be in the vector's range. */ - ItemType& operator[]( SizeType index ) + ItemType& operator[](SizeType index) { // reuse the const version - return const_cast< ItemType& >( const_cast< const Vector< ItemType >& >( *this )[ index ] ); + return const_cast(const_cast&>(*this)[index]); } /** * @brief Subscript operator. * @SINCE_1_0.0 - * @param[in] index of the element. - * @return reference to the element for given index. - * @pre index must be in the vector's range. + * @param[in] index Index of the element + * @return Reference to the element for given index + * @pre Index must be in the vector's range. */ - const ItemType& operator[]( SizeType index ) const + const ItemType& operator[](SizeType index) const { - DALI_ASSERT_VECTOR( VectorBase::mData && "Vector is empty" ); - DALI_ASSERT_VECTOR( index < VectorBase::Count() && "Index out of bounds" ); - ItemType* address = reinterpret_cast( VectorBase::mData ); + DALI_ASSERT_VECTOR(VectorBase::mData && "Vector is empty"); + DALI_ASSERT_VECTOR(index < VectorBase::Count() && "Index out of bounds"); + ItemType* address = reinterpret_cast(VectorBase::mData); address += index; return *address; } /** - * @brief Push back an element to the vector. + * @brief Pushes back an element to the vector. * * The underlying storage may be reallocated to provide space. * If this occurs, all pre-existing pointers into the vector will * become invalid. * * @SINCE_1_0.0 - * @param[in] element Element to be added. + * @param[in] element Element to be added */ - void PushBack( const ItemType& element ) + void PushBack(const ItemType& element) { - const SizeType count = VectorBase::Count(); + const SizeType count = VectorBase::Count(); const SizeType newCount = count + 1u; const SizeType capacity = VectorBase::Capacity(); - if( newCount > capacity ) + if(newCount > capacity) { // need more space - Reserve( newCount << 1u ); // reserve double the current count + Reserve(newCount << 1u); // reserve double the current count } // set new count first as otherwise the debug assert will hit us - VectorBase::SetCount( newCount ); - operator[]( count ) = element; + VectorBase::SetCount(newCount); + operator[](count) = element; } /** - *@brief Insert an element to the vector. + * @brief Inserts an element to the vector. * * Elements after \e at are moved one position to the right. * @@ -551,21 +588,20 @@ public: // API * If this occurs, all pre-existing pointers into the vector will * become invalid. * + * @SINCE_1_0.0 + * @param[in] at Iterator where to insert the elements into the vector + * @param[in] element An element to be added * @pre Iterator at must be in the vector's range ( Vector::Begin(), Vector::End() ). - * - * @param[in] at Iterator where to insert the elements into the vector. - * @param[in] element An element to be added. - *@SINCE_1_0.0 */ - void Insert( Iterator at, const ItemType& element ) + void Insert(Iterator at, const ItemType& element) { - DALI_ASSERT_VECTOR( ( at <= End() ) && ( at >= Begin() ) && "Iterator not inside vector" ); - const SizeType size = sizeof( ItemType ); - char* address = const_cast( reinterpret_cast( &element ) ); - VectorAlgorithms::Insert( reinterpret_cast< char* >( at ), - address, - address + size, - size ); + DALI_ASSERT_VECTOR((at <= End()) && (at >= Begin()) && "Iterator not inside vector"); + const SizeType size = sizeof(ItemType); + uint8_t* address = const_cast(reinterpret_cast(&element)); + VectorAlgorithms::Insert(reinterpret_cast(at), + address, + address + size, + size); } /** @@ -578,142 +614,155 @@ public: // API * become invalid. * * @SINCE_1_0.0 - * @param[in] at Iterator where to insert the elements into the vector. - * @param[in] from Iterator to the first element to be inserted. - * @param[in] to Iterator to the last element to be inserted. + * @param[in] at Iterator where to insert the elements into the vector + * @param[in] from Iterator to the first element to be inserted + * @param[in] to Iterator to the last element to be inserted * @pre Iterator \e at must be in the vector's range ( Vector::Begin(), Vector::End() ). * @pre Iterators \e from and \e to must be valid iterators. * @pre Iterator \e from must not be grater than Iterator \e to. * */ - void Insert( Iterator at, Iterator from, Iterator to ) + void Insert(Iterator at, Iterator from, Iterator to) { - DALI_ASSERT_VECTOR( ( at <= End() ) && ( at >= Begin() ) && "Iterator not inside vector" ); - DALI_ASSERT_VECTOR( ( from <= to ) && "from address can't be greater than to" ); + DALI_ASSERT_VECTOR((at <= End()) && (at >= Begin()) && "Iterator not inside vector"); + DALI_ASSERT_VECTOR((from <= to) && "from address can't be greater than to"); - if( from == to ) + if(from == to) { // nothing to copy. return; } - VectorAlgorithms::Insert( reinterpret_cast< char* >( at ), - reinterpret_cast< char* >( from ), - reinterpret_cast< char* >( to ), - sizeof( ItemType ) ); + VectorAlgorithms::Insert(reinterpret_cast(at), + reinterpret_cast(from), + reinterpret_cast(to), + sizeof(ItemType)); } /** - * @brief Reserve space in the vector. + * @brief Reserves space in the vector. * * Reserving less than current Capacity is a no-op. * @SINCE_1_0.0 - * @param[in] count Count of elements to reserve. + * @param[in] count Count of elements to reserve */ - void Reserve( SizeType count ) + void Reserve(SizeType count) { - VectorAlgorithms::Reserve( count, sizeof( ItemType ) ); + VectorAlgorithms::Reserve(count, sizeof(ItemType)); } /** - * @brief Resize the vector. Does not change capacity. + * @brief Resizes the vector. Does not change capacity. * * @SINCE_1_0.0 - * @param[in] count Count to resize to. + * @param[in] count Count to resize to */ - void Resize( SizeType count ) + void Resize(SizeType count) { ItemType item = ItemType(); Resize(count, item); } /** - * @brief Resize the vector. Does not change capacity. + * @brief Resizes the vector without initializing the data. + * + * Can be used as a data container for reading whole file content. + * @SINCE_1_9.27 + * @param[in] count Count to resize to + */ + void ResizeUninitialized(SizeType count) + { + Reserve(count); + VectorBase::SetCount(count); + } + + /** + * @brief Resizes the vector. Does not change capacity. * * @SINCE_1_0.0 - * @param[in] count Count to resize to. - * @param[in] item An item to insert to the new indices. + * @param[in] count Count to resize to + * @param[in] item An item to insert to the new indices */ - void Resize( SizeType count, const ItemType& item ) + void Resize(SizeType count, const ItemType& item) { const SizeType oldCount = VectorBase::Count(); - if( count <= oldCount ) + if(count <= oldCount) { // getting smaller so just set count - VectorBase::SetCount( count ); + VectorBase::SetCount(count); } else { // remember how many new items get added SizeType newItems = count - oldCount; - Reserve( count ); - for( ; newItems > 0u; --newItems ) + Reserve(count); + for(; newItems > 0u; --newItems) { - PushBack( item ); + PushBack(item); } } } /** - * @brief Erase an element. + * @brief Erases an element. * * Does not change capacity. Other elements get moved. * * @SINCE_1_0.0 - * @param[in] iterator Iterator pointing to item to remove. - * @return Iterator pointing to next element. + * @param[in] iterator Iterator pointing to the item to remove + * @return Iterator pointing to next element * @pre Iterator \e iterator must be within the vector's range ( Vector::Begin(), Vector::End() - 1 ). * */ - Iterator Erase( Iterator iterator ) + Iterator Erase(Iterator iterator) { - DALI_ASSERT_VECTOR( (iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector" ); - if( iterator < ( End() - 1u ) ) + DALI_ASSERT_VECTOR((iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector"); + if(iterator < (End() - 1u)) { - VectorAlgorithms::Erase( reinterpret_cast< char* >( iterator ), sizeof( ItemType ) ); + VectorAlgorithms::Erase(reinterpret_cast(iterator), sizeof(ItemType)); } else { // just remove the element - Remove( iterator ); + Remove(iterator); } return iterator; } /** - * @brief Erase a range of elements. + * @brief Erases a range of elements. * * Does not change capacity. Other elements get moved. * * @SINCE_1_0.0 - * @param[in] first Iterator to the first element to be erased. - * @param[in] last Iterator to the last element to be erased. + * @param[in] first Iterator to the first element to be erased + * @param[in] last Iterator to the last element to be erased * - * @return Iterator pointing to the next element of the last one. + * @return Iterator pointing to the next element of the last one * @pre Iterator \e first must be in the vector's range ( Vector::Begin(), Vector::End() ). * @pre Iterator \e last must be in the vector's range ( Vector::Begin(), Vector::End() ). * @pre Iterator \e first must not be grater than Iterator \e last. * */ - Iterator Erase( Iterator first, Iterator last ) + Iterator Erase(Iterator first, Iterator last) { - DALI_ASSERT_VECTOR( ( first <= End() ) && ( first >= Begin() ) && "Iterator not inside vector" ); - DALI_ASSERT_VECTOR( ( last <= End() ) && ( last >= Begin() ) && "Iterator not inside vector" ); - DALI_ASSERT_VECTOR( ( first <= last ) && "first iterator greater than last" ); + DALI_ASSERT_VECTOR((first <= End()) && (first >= Begin()) && "Iterator not inside vector"); + DALI_ASSERT_VECTOR((last <= End()) && (last >= Begin()) && "Iterator not inside vector"); + DALI_ASSERT_VECTOR((first <= last) && "first iterator greater than last"); Iterator nextElement; - if( last == End() ) + if(last == End()) { // Erase up to the end. - VectorBase::SetCount( VectorBase::Count() - ( last - first ) ); + VectorBase::SetCount(VectorBase::Count() - (last - first)); nextElement = End(); } else { - nextElement = reinterpret_cast( VectorAlgorithms::Erase( reinterpret_cast< char* >( first ), - reinterpret_cast< char* >( last ), - sizeof( ItemType ) ) ); + nextElement = reinterpret_cast(VectorAlgorithms::Erase(reinterpret_cast(first), + reinterpret_cast(last), + sizeof(ItemType))); } return nextElement; @@ -722,40 +771,40 @@ public: // API /** * @brief Removes an element. * - * Does not maintain order. Swaps the element with end and + * Does not maintain order. Swaps the element with end and * decreases size by one. This is much faster than Erase so use * this in case order does not matter. Does not change capacity. * * @SINCE_1_0.0 - * @param[in] iterator Iterator pointing to item to remove. + * @param[in] iterator Iterator pointing to the item to remove * @pre Iterator \e iterator must be in the vector's range ( Vector::Begin(), Vector::End() - 1 ). * */ - void Remove( Iterator iterator ) + void Remove(Iterator iterator) { - DALI_ASSERT_VECTOR( (iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector" ); + DALI_ASSERT_VECTOR((iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector"); Iterator last = End() - 1u; - if( last > iterator ) + if(last > iterator) { - std::swap( *iterator, *last ); + std::swap(*iterator, *last); } - VectorBase::SetCount( VectorBase::Count() - 1u ); + VectorBase::SetCount(VectorBase::Count() - 1u); } /** - * @brief Swap the contents of two vectors. + * @brief Swaps the contents of two vectors. * * @SINCE_1_0.0 - * @param[in] vector Vector to swap with. + * @param[in] vector Vector to swap with */ - void Swap( Vector& vector ) + void Swap(Vector& vector) { - VectorBase::Swap( vector ); + VectorBase::Swap(vector); } /** - * @brief Clear the contents of the vector. Keeps its capacity. + * @brief Clears the contents of the vector. Keeps its capacity. * @SINCE_1_0.0 */ void Clear() @@ -764,7 +813,7 @@ public: // API } /** - * @brief Release the memory that the vector holds. + * @brief Releases the memory that the vector holds. * @SINCE_1_0.0 */ void Release() @@ -774,8 +823,40 @@ public: // API }; /** + * @brief Erases all elements that compare equal to value from the vector. + * + * @SINCE_1_9.33 + * @param[in] vector The vector + * @param[in] value The value to be removed. + */ +template +inline void Erase(Dali::Vector& vector, const U& value) +{ + auto begin = vector.Begin(); + auto end = vector.End(); + + vector.Erase(std::remove(begin, end, value), end); +} + +/** + * @brief Erases all elements that satisfy the predicate from the vector. + * + * @SINCE_1_9.33 + * @param[in] vector The vector + * @param[in] predicate The predicate + */ +template +inline void EraseIf(Dali::Vector& vector, Predicate predicate) +{ + auto begin = vector.Begin(); + auto end = vector.End(); + + vector.Erase(std::remove_if(begin, end, predicate), end); +} + +/** * @} */ } // namespace Dali -#endif /* __DALI_VECTOR_H__ */ +#endif // DALI_VECTOR_H