dali/public-api/common/dali-vector.h

   1 #ifndef __DALI_VECTOR_H__
   2 #define __DALI_VECTOR_H__
   3
   4 /*
   5  * Copyright (c) 2017 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>
  23 #include <algorithm>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/public-api/common/dali-common.h>
  27 #include <dali/public-api/common/type-traits.h>
  28 #include <dali/public-api/math/math-utils.h>
  29
  30 /**
  31  * @brief For DALi internal use, asserts are enabled in debug builds.
  32  *
  33  * For Application use, asserts can be enabled manually.
  34  * @SINCE_1_0.0
  35  */
  36 #if defined( DEBUG_ENABLED )
  37 #define ENABLE_VECTOR_ASSERTS
  38 #endif
  39
  40 #if defined( ENABLE_VECTOR_ASSERTS )
  41 #define DALI_ASSERT_VECTOR(cond) DALI_ASSERT_ALWAYS(cond)
  42 #else
  43 #define DALI_ASSERT_VECTOR(cond)
  44 #endif
  45
  46 namespace Dali
  47 {
  48 /**
  49  * @addtogroup dali_core_common
  50  * @{
  51  */
  52
  53 /**
  54  * @brief Base class to handle the memory of simple vector.
  55  *
  56  * Memory layout is such that it has two std::size_t to hold the count
  57  * and capacity of the vector. VectorBase::mData is adjusted so that it points to the
  58  * beginning of the first real item so that iterating the items is quick.
  59  * @SINCE_1_0.0
  60  */
  61 class DALI_IMPORT_API VectorBase
  62 {
  63 public: // Typedefs
  64
  65   typedef std::size_t SizeType;
  66
  67 protected: // Construction
  68
  69   /**
  70    * @brief Default constructor. Does not allocate space.
  71    * @SINCE_1_0.0
  72    */
  73   VectorBase();
  74
  75   /**
  76    * @brief Destructor.
  77    *
  78    * Does not release the space. Derived class needs to call Release.
  79    * Not virtual as this should not be called directly and we do not want
  80    * a vtable for this class as it would unnecessarily increase size.
  81    * @SINCE_1_0.0
  82    */
  83   ~VectorBase();
  84
  85 public: // API
  86
  87   /**
  88    * @brief This method is inlined as it's needed frequently for Vector::End() iterator.
  89    *
  90    * @SINCE_1_0.0
  91    * @return The count of elements in this vector
  92    */
  93   SizeType Count() const
  94   {
  95     SizeType items = 0u;
  96     if( mData )
  97     {
  98       SizeType* metadata = reinterpret_cast< SizeType* >( mData );
  99       items = *(metadata - 1u);
 100     }
 101     return items;
 102   }
 103
 104   /**
 105    * @brief Gets the count of elements in this vector.
 106    * @SINCE_1_0.0
 107    * @return The count of elements in this vector
 108    */
 109   SizeType Size() const
 110   {
 111     return Count();
 112   }
 113
 114   /**
 115    * @brief @ return if the vector is empty.
 116    * @SINCE_1_0.0
 117    * @return True if the count of elements is empty
 118    */
 119   bool Empty() const
 120   {
 121     return Count() == 0u;
 122   }
 123
 124   /**
 125    * @brief Gets the capacity of this vector.
 126    * @SINCE_1_0.0
 127    * @return The capacity of this vector
 128    */
 129   SizeType Capacity() const;
 130
 131   /**
 132    * @brief Releases the data.
 133    *
 134    * Does not call destructors on objects held.
 135    * @SINCE_1_0.0
 136    */
 137   void Release();
 138
 139 protected: // for Derived classes
 140
 141   /**
 142    * @brief Helper to set the count.
 143    *
 144    * @SINCE_1_0.0
 145    * @param[in] count Number of elements in the vector
 146    */
 147   void SetCount( SizeType count );
 148
 149   /**
 150    * @brief Reserves space in the vector.
 151    *
 152    * @SINCE_1_0.0
 153    * @param[in] count Count of elements to reserve
 154    * @param[in] elementSize Size of a single element
 155    */
 156   void Reserve( SizeType count, SizeType elementSize );
 157
 158   /**
 159    * @brief Copy a vector.
 160    *
 161    * @SINCE_1_0.0
 162    * @param[in] vector Vector to copy from
 163    * @param[in] elementSize Size of a single element
 164    */
 165   void Copy( const VectorBase& vector, SizeType elementSize );
 166
 167   /**
 168    * @brief Swaps the contents of two vectors.
 169    *
 170    * @SINCE_1_0.0
 171    * @param[in] vector Vector to swap with
 172    */
 173   void Swap( VectorBase& vector );
 174
 175   /**
 176    * @brief Erases an element.
 177    *
 178    * Does not change capacity.
 179    * @SINCE_1_0.0
 180    * @param[in] address Address to erase from
 181    * @param[in] elementSize Size to erase
 182    * @pre Last element cannot be erased as there is nothing to move.
 183    */
 184   void Erase( char* address, SizeType elementSize );
 185
 186   /**
 187    * @brief Erases a range of elements.
 188    *
 189    * Does not change capacity.
 190    * @SINCE_1_0.0
 191    * @param[in] first Address to the first element to be erased
 192    * @param[in] last Address to the last element to be erased
 193    * @param[in] elementSize Size of one of the elements to be erased
 194    * @return Address pointing to the next element of the last one
 195    */
 196   char* Erase( char* first, char* last, SizeType elementSize );
 197
 198   /**
 199    * @brief Copies a number of bytes from \e source to \e destination.
 200    *
 201    * \e source and \e destination must not overlap.
 202    *
 203    * @SINCE_1_0.0
 204    * @param[in] destination Pointer to the destination address
 205    * @param[in] source Pointer to the source address
 206    * @param[in] numberOfBytes The number of bytes to be copied
 207    */
 208   void CopyMemory( char* destination, const char* source, size_t numberOfBytes );
 209
 210 private:
 211
 212   // not copiable as it does not know the size of elements
 213   VectorBase( const VectorBase& ); ///< Undefined @SINCE_1_0.0
 214   VectorBase& operator=( const VectorBase& ); ///< Undefined @SINCE_1_0.0
 215
 216 protected: // Data
 217
 218   void* mData; ///< Pointer to the data.
 219
 220 };
 221
 222 /**
 223  * @brief Vector algorithm variant for trivial types.
 224  *
 225  * Trivial types do not need destructor or copy constructor called.
 226  * @SINCE_1_0.0
 227  */
 228 template< bool IsTrivial >
 229 class VectorAlgorithms : public VectorBase
 230 {
 231 protected: // API for deriving classes
 232
 233   typedef VectorBase::SizeType SizeType;
 234
 235   /**
 236    * @brief Empty constructor.
 237    * @SINCE_1_0.0
 238    */
 239   VectorAlgorithms()
 240   { }
 241
 242   /**
 243    * @brief Empty destructor.
 244    * @SINCE_1_0.0
 245    */
 246   ~VectorAlgorithms()
 247   { }
 248
 249   /**
 250    * @brief Copy vector contents.
 251    *
 252    * @SINCE_1_0.0
 253    * @param[in] rhs VectorBase object to copy from
 254    * @param[in] elementSize Size of the content
 255    */
 256   void Copy( const VectorBase& rhs, SizeType elementSize )
 257   {
 258     if( rhs.Capacity() > 0u )
 259     {
 260       VectorBase::Copy( rhs, elementSize );
 261     }
 262     else
 263     {
 264       VectorBase::Release();
 265     }
 266   }
 267
 268   /**
 269    * @brief Reserves space in the vector.
 270    *
 271    * @SINCE_1_0.0
 272    * @param[in] count Count of elements to reserve
 273    * @param[in] elementSize Size of a single element
 274    */
 275   void Reserve( SizeType count, SizeType elementSize )
 276   {
 277     VectorBase::Reserve( count, elementSize );
 278   }
 279
 280   /**
 281    * @brief Resizes the vector. Does not change capacity.
 282    *
 283    * @SINCE_1_0.0
 284    * @param[in] count Count to resize to
 285    * @param[in] elementSize Size of a single element
 286    */
 287   void Resize( SizeType count, SizeType elementSize )
 288   {
 289     // reserve will copy old elements as well
 290     Reserve( count, elementSize );
 291   }
 292
 293   /**
 294    * @brief Clears the contents.
 295    *
 296    * For simple types, nothing to do.
 297    * @SINCE_1_0.0
 298    */
 299   void Clear()
 300   {
 301     if( mData )
 302     {
 303       VectorBase::SetCount( 0u );
 304     }
 305   }
 306
 307   /**
 308    * @brief Releases the vector.
 309    * @SINCE_1_0.0
 310    */
 311   void Release()
 312   {
 313     VectorBase::Release();
 314   }
 315
 316   /**
 317    * @brief Erases an element. Does not change capacity.
 318    *
 319    * @SINCE_1_0.0
 320    * @param[in] address Address to erase from
 321    * @param[in] elementSize Size to erase
 322    */
 323   void Erase( char* address, SizeType elementSize )
 324   {
 325     VectorBase::Erase( address, elementSize );
 326   }
 327
 328   /**
 329    * @brief Erases a range of elements. Does not change capacity.
 330    *
 331    * @SINCE_1_0.0
 332    * @param[in] first Address to the first element to be erased
 333    * @param[in] last Address to the last element to be erased
 334    * @param[in] elementSize Size of one of the elements to be erased
 335    * @return Address pointing to the next element of the last one
 336    */
 337   char* Erase( char* first, char* last, SizeType elementSize )
 338   {
 339     return VectorBase::Erase( first, last, elementSize );
 340   }
 341
 342   /**
 343    * @brief Inserts the given elements into the vector.
 344    *
 345    * @SINCE_1_0.0
 346    * @param[in] at Address where to insert the elements into the vector
 347    * @param[in] from Address to the first element to be inserted
 348    * @param[in] to Address to the last element to be inserted
 349    * @param[in] elementSize Size of one of the elements to be inserted
 350    */
 351   void Insert( char* at, char* from, char* to, SizeType elementSize )
 352   {
 353     const SizeType size = to - from;
 354     const SizeType count = Count();
 355     const SizeType newCount = count + size / elementSize;
 356
 357     if( newCount > Capacity() )
 358     {
 359       // Calculate the at offset as the pointer is invalid after the Reserve() call.
 360       std::size_t offset = at - reinterpret_cast<char*>( mData );
 361
 362       // need more space
 363       Reserve( NextPowerOfTwo( newCount ), elementSize ); // reserve enough space to store at least the next power of two elements of the new required size.
 364
 365       // Set the new at pointer.
 366       at = reinterpret_cast<char*>( mData ) + offset;
 367     }
 368     // set new count first as otherwise the debug assert will hit us
 369     SetCount( newCount );
 370
 371     // Move current items to a new position inside the vector.
 372     CopyMemory( at + size,
 373                 at,
 374                 ( reinterpret_cast<char*>( mData ) + count * elementSize ) - at );
 375
 376     // Copy the given items.
 377     CopyMemory( at, from, size );
 378   }
 379 };
 380
 381 /**
 382  * @brief Vector algorithm variant for complex types.
 383  *
 384  * Not yet supported so will lead to compile error
 385  * as constructor and destructor are private.
 386  * TODO add support for this variant.
 387  * @SINCE_1_0.0
 388  */
 389 template<>
 390 class VectorAlgorithms< false > : public VectorBase
 391 {
 392 private:
 393   VectorAlgorithms()
 394   { }
 395   ~VectorAlgorithms()
 396   { }
 397 };
 398
 399 /**
 400  * @brief Vector class with minimum space allocation when it's empty.
 401  *
 402  * @SINCE_1_0.0
 403  * @param type The type of the data that the vector holds
 404  */
 405 template< class T, bool IsTrivialType = TypeTraits<T>::IS_TRIVIAL_TYPE == true >
 406 class Vector : public VectorAlgorithms< IsTrivialType >
 407 {
 408 public: // API
 409
 410   /**
 411    * @brief Type definitions.
 412    * @SINCE_1_0.0
 413    */
 414   typedef VectorBase::SizeType SizeType; ///< Size type @SINCE_1_0.0
 415   typedef T* Iterator;  ///< Most simple Iterator is a pointer @SINCE_1_0.0
 416   typedef const T* ConstIterator; ///< Const iterator @SINCE_1_0.0
 417   typedef T  ItemType; ///< Item type @SINCE_1_0.0
 418
 419   /**
 420    * @brief Enumeration for BaseType.
 421    * @SINCE_1_0.0
 422    */
 423   enum
 424   {
 425     BaseType = IsTrivialType ///< @SINCE_1_0.0
 426   };
 427
 428   /**
 429    * @brief Default constructor. Does not allocate any space.
 430    * @SINCE_1_0.0
 431    */
 432   Vector()
 433   { }
 434
 435   /**
 436    * @brief Destructor. Releases the allocated space.
 437    * @SINCE_1_0.0
 438    */
 439   ~Vector()
 440   {
 441     Release();
 442   }
 443
 444   /**
 445    * @brief Copy constructor.
 446    *
 447    * @SINCE_1_0.0
 448    * @param[in] vector Vector to copy from
 449    */
 450   Vector( const Vector& vector )
 451   {
 452     // reuse assignment
 453     operator=( vector );
 454   }
 455
 456   /**
 457    * @brief Assignment operator.
 458    *
 459    * @SINCE_1_0.0
 460    * @param[in] vector Vector to assign from
 461    * @return Reference to self for chaining
 462    */
 463   Vector& operator=( const Vector& vector )
 464   {
 465     if( this != &vector )
 466     {
 467       VectorAlgorithms<BaseType>::Copy( vector, sizeof( ItemType ) );
 468     }
 469     return *this;
 470   }
 471
 472   /**
 473    * @brief Iterator to the beginning of the data.
 474    * @SINCE_1_0.0
 475    * @return Iterator to the beginning of the data
 476    */
 477   Iterator Begin() const
 478   {
 479     ItemType* address = reinterpret_cast<ItemType*>( VectorBase::mData );
 480     return address;
 481   }
 482
 483   /**
 484    * @brief Iterator to the end of the data (one past last element).
 485    * @SINCE_1_0.0
 486    * @return Iterator to the end of the data (one past last element)
 487    */
 488   Iterator End() const
 489   {
 490     ItemType* address = reinterpret_cast<ItemType*>( VectorBase::mData );
 491     address += VectorBase::Count();
 492     return address;
 493   }
 494
 495   /**
 496    * Support for C++11 Range-based for loop: for( item : container ).
 497    * @SINCE_1_2.60
 498    * @return The start iterator
 499    */
 500   Iterator begin() const
 501   {
 502     return Begin();
 503   }
 504
 505   /**
 506    * Support for C++11 Range-based for loop: for( item : container ).
 507    * @SINCE_1_2.60
 508    * @return The end iterator
 509    */
 510   Iterator end() const
 511   {
 512     return End();
 513   }
 514
 515   /**
 516    * @brief Subscript operator.
 517    * @SINCE_1_0.0
 518    * @param[in] index Index of the element
 519    * @return Reference to the element for given index
 520    * @pre Index must be in the vector's range.
 521    */
 522   ItemType& operator[]( SizeType index )
 523   {
 524     // reuse the const version
 525     return const_cast< ItemType& >( const_cast< const Vector< ItemType >& >( *this )[ index ] );
 526   }
 527
 528   /**
 529    * @brief Subscript operator.
 530    * @SINCE_1_0.0
 531    * @param[in] index Index of the element
 532    * @return Reference to the element for given index
 533    * @pre Index must be in the vector's range.
 534    */
 535   const ItemType& operator[]( SizeType index ) const
 536   {
 537     DALI_ASSERT_VECTOR( VectorBase::mData && "Vector is empty" );
 538     DALI_ASSERT_VECTOR( index < VectorBase::Count() && "Index out of bounds" );
 539     ItemType* address = reinterpret_cast<ItemType*>( VectorBase::mData );
 540     address += index;
 541     return *address;
 542   }
 543
 544   /**
 545    * @brief Pushes back an element to the vector.
 546    *
 547    * The underlying storage may be reallocated to provide space.
 548    * If this occurs, all pre-existing pointers into the vector will
 549    * become invalid.
 550    *
 551    * @SINCE_1_0.0
 552    * @param[in] element Element to be added
 553    */
 554   void PushBack( const ItemType& element )
 555   {
 556     const SizeType count = VectorBase::Count();
 557     const SizeType newCount = count + 1u;
 558     const SizeType capacity = VectorBase::Capacity();
 559     if( newCount > capacity )
 560     {
 561       // need more space
 562       Reserve( newCount << 1u ); // reserve double the current count
 563     }
 564     // set new count first as otherwise the debug assert will hit us
 565     VectorBase::SetCount( newCount );
 566     operator[]( count ) = element;
 567   }
 568
 569   /**
 570    * @brief Inserts an element to the vector.
 571    *
 572    * Elements after \e at are moved one position to the right.
 573    *
 574    * The underlying storage may be reallocated to provide space.
 575    * If this occurs, all pre-existing pointers into the vector will
 576    * become invalid.
 577    *
 578    * @SINCE_1_0.0
 579    * @param[in] at Iterator where to insert the elements into the vector
 580    * @param[in] element An element to be added
 581    * @pre Iterator at must be in the vector's range ( Vector::Begin(), Vector::End() ).
 582    */
 583   void Insert( Iterator at, const ItemType& element )
 584   {
 585     DALI_ASSERT_VECTOR( ( at <= End() ) && ( at >= Begin() ) && "Iterator not inside vector" );
 586     const SizeType size = sizeof( ItemType );
 587     char* address = const_cast<char*>( reinterpret_cast<const char*>( &element ) );
 588     VectorAlgorithms<BaseType>::Insert( reinterpret_cast< char* >( at ),
 589                                         address,
 590                                         address + size,
 591                                         size );
 592   }
 593
 594   /**
 595    * @brief Inserts the given elements into the vector.
 596    *
 597    * Elements after \e at are moved the number of given elements positions to the right.
 598    *
 599    * The underlying storage may be reallocated to provide space.
 600    * If this occurs, all pre-existing pointers into the vector will
 601    * become invalid.
 602    *
 603    * @SINCE_1_0.0
 604    * @param[in] at Iterator where to insert the elements into the vector
 605    * @param[in] from Iterator to the first element to be inserted
 606    * @param[in] to Iterator to the last element to be inserted
 607    * @pre Iterator \e at must be in the vector's range ( Vector::Begin(), Vector::End() ).
 608    * @pre Iterators \e from and \e to must be valid iterators.
 609    * @pre Iterator \e from must not be grater than Iterator \e to.
 610    *
 611    */
 612   void Insert( Iterator at, Iterator from, Iterator to )
 613   {
 614     DALI_ASSERT_VECTOR( ( at <= End() ) && ( at >= Begin() ) && "Iterator not inside vector" );
 615     DALI_ASSERT_VECTOR( ( from <= to ) && "from address can't be greater than to" );
 616
 617     if( from == to )
 618     {
 619       // nothing to copy.
 620       return;
 621     }
 622
 623     VectorAlgorithms<BaseType>::Insert( reinterpret_cast< char* >( at ),
 624                                         reinterpret_cast< char* >( from ),
 625                                         reinterpret_cast< char* >( to ),
 626                                         sizeof( ItemType ) );
 627   }
 628
 629   /**
 630    * @brief Reserves space in the vector.
 631    *
 632    * Reserving less than current Capacity is a no-op.
 633    * @SINCE_1_0.0
 634    * @param[in] count Count of elements to reserve
 635    */
 636   void Reserve( SizeType count )
 637   {
 638     VectorAlgorithms<BaseType>::Reserve( count, sizeof( ItemType ) );
 639   }
 640
 641   /**
 642    * @brief Resizes the vector. Does not change capacity.
 643    *
 644    * @SINCE_1_0.0
 645    * @param[in] count Count to resize to
 646    */
 647   void Resize( SizeType count )
 648   {
 649     ItemType item = ItemType();
 650     Resize(count, item);
 651   }
 652
 653   /**
 654    * @brief Resizes the vector. Does not change capacity.
 655    *
 656    * @SINCE_1_0.0
 657    * @param[in] count Count to resize to
 658    * @param[in] item An item to insert to the new indices
 659    */
 660   void Resize( SizeType count, const ItemType& item )
 661   {
 662     const SizeType oldCount = VectorBase::Count();
 663     if( count <= oldCount )
 664     {
 665       // getting smaller so just set count
 666       VectorBase::SetCount( count );
 667     }
 668     else
 669     {
 670       // remember how many new items get added
 671       SizeType newItems = count - oldCount;
 672       Reserve( count );
 673       for( ; newItems > 0u; --newItems )
 674       {
 675         PushBack( item );
 676       }
 677     }
 678   }
 679
 680   /**
 681    * @brief Erases an element.
 682    *
 683    * Does not change capacity. Other elements get moved.
 684    *
 685    * @SINCE_1_0.0
 686    * @param[in] iterator Iterator pointing to the item to remove
 687    * @return Iterator pointing to next element
 688    * @pre Iterator \e iterator must be within the vector's range ( Vector::Begin(), Vector::End() - 1 ).
 689    *
 690    */
 691   Iterator Erase( Iterator iterator )
 692   {
 693     DALI_ASSERT_VECTOR( (iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector" );
 694     if( iterator < ( End() - 1u ) )
 695     {
 696       VectorAlgorithms<BaseType>::Erase( reinterpret_cast< char* >( iterator ), sizeof( ItemType ) );
 697     }
 698     else
 699     {
 700       // just remove the element
 701       Remove( iterator );
 702     }
 703     return iterator;
 704   }
 705
 706   /**
 707    * @brief Erases a range of elements.
 708    *
 709    * Does not change capacity. Other elements get moved.
 710    *
 711    * @SINCE_1_0.0
 712    * @param[in] first Iterator to the first element to be erased
 713    * @param[in] last Iterator to the last element to be erased
 714    *
 715    * @return Iterator pointing to the next element of the last one
 716    * @pre Iterator \e first must be in the vector's range ( Vector::Begin(), Vector::End() ).
 717    * @pre Iterator \e last must be in the vector's range ( Vector::Begin(), Vector::End() ).
 718    * @pre Iterator \e first must not be grater than Iterator \e last.
 719    *
 720    */
 721   Iterator Erase( Iterator first, Iterator last )
 722   {
 723     DALI_ASSERT_VECTOR( ( first <= End() ) && ( first >= Begin() ) && "Iterator not inside vector" );
 724     DALI_ASSERT_VECTOR( ( last <= End() ) && ( last >= Begin() ) && "Iterator not inside vector" );
 725     DALI_ASSERT_VECTOR( ( first <= last ) && "first iterator greater than last" );
 726
 727     Iterator nextElement;
 728
 729     if( last == End() )
 730     {
 731       // Erase up to the end.
 732       VectorBase::SetCount( VectorBase::Count() - ( last - first ) );
 733       nextElement = End();
 734     }
 735     else
 736     {
 737       nextElement = reinterpret_cast<Iterator>( VectorAlgorithms<BaseType>::Erase( reinterpret_cast< char* >( first ),
 738                                                                                    reinterpret_cast< char* >( last ),
 739                                                                                    sizeof( ItemType ) ) );
 740     }
 741
 742     return nextElement;
 743   }
 744
 745   /**
 746    * @brief Removes an element.
 747    *
 748    * Does not maintain order. Swaps the element with end and
 749    * decreases size by one.  This is much faster than Erase so use
 750    * this in case order does not matter. Does not change capacity.
 751    *
 752    * @SINCE_1_0.0
 753    * @param[in] iterator Iterator pointing to the item to remove
 754    * @pre Iterator \e iterator must be in the vector's range ( Vector::Begin(), Vector::End() - 1 ).
 755    *
 756    */
 757   void Remove( Iterator iterator )
 758   {
 759     DALI_ASSERT_VECTOR( (iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector" );
 760
 761     Iterator last = End() - 1u;
 762     if( last > iterator )
 763     {
 764       std::swap( *iterator, *last );
 765     }
 766     VectorBase::SetCount( VectorBase::Count() - 1u );
 767   }
 768
 769   /**
 770    * @brief Swaps the contents of two vectors.
 771    *
 772    * @SINCE_1_0.0
 773    * @param[in] vector Vector to swap with
 774    */
 775   void Swap( Vector& vector )
 776   {
 777     VectorBase::Swap( vector );
 778   }
 779
 780   /**
 781    * @brief Clears the contents of the vector. Keeps its capacity.
 782    * @SINCE_1_0.0
 783    */
 784   void Clear()
 785   {
 786     VectorAlgorithms<BaseType>::Clear();
 787   }
 788
 789   /**
 790    * @brief Releases the memory that the vector holds.
 791    * @SINCE_1_0.0
 792    */
 793   void Release()
 794   {
 795     VectorAlgorithms<BaseType>::Release();
 796   }
 797 };
 798
 799 /**
 800  * @}
 801  */
 802 } // namespace Dali
 803
 804 #endif /* __DALI_VECTOR_H__ */