inc/FBaseColArrayList.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FBaseColArrayList.h
  20  * @brief               This is the header file for the %ArrayList class.
  21  *
  22  * This header file contains the declarations of the %ArrayList class.
  23  */
  24 #ifndef _FBASE_COL_ARRAY_LIST_H_
  25 #define _FBASE_COL_ARRAY_LIST_H_
  26
  27 #include <FBaseObject.h>
  28 #include <FBaseColIComparer.h>
  29 #include <FBaseColIList.h>
  30
  31
  32 namespace Tizen { namespace Base { namespace Collection
  33 {
  34
  35 /**
  36  * @class ArrayList
  37  * @brief This class represents a collection of objects that can be individually accessed by an index.
  38  *
  39  * @since 2.0
  40  *
  41  *
  42  * The %ArrayList class represents a collection of objects that can be individually accessed by an index.
  43  *
  44  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/base/arraylist_linkedlist.htm">ArrayList and LinkedList</a>.
  45  *
  46  * The following example demonstrates how to use the %ArrayList class.
  47  *
  48  * @code
  49  *
  50  *      #include <FBase.h>
  51  *
  52  *      using namespace Tizen::Base;
  53  *      using namespace Tizen::Base::Collection;
  54  *
  55  *
  56  *      void
  57  *      MyClass::ArrayListSample(void)
  58  *      {
  59  *              ArrayList       list(SingleObjectDeleter);
  60  *
  61  *              list.Construct();
  62  *
  63  *              list.Add(new Integer(1));       // 1
  64  *              list.Add(new Integer(2));       // 1,2
  65  *              list.Add(new Integer(3));       // 1,2,3
  66  *
  67  *              Integer*        pInt = static_cast< Integer* > (list.GetAt(0));
  68  *
  69  *              if (pInt->Equals(Integer(1)))
  70  *              {
  71  *                      // Must be here
  72  *              }
  73  *
  74  *              list.InsertAt(new Integer(4), 1);       // 1,4,2,3
  75  *
  76  *              list.Remove(Integer(3));                // 1,4,2
  77  *
  78  *              list.RemoveAt(0);                               // 4,2
  79  *
  80  *              list.Sort(IntegerComparer());   // 2,4
  81  *
  82  *              // Uses an enumerator to access elements in the list
  83  *              IEnumerator*    pEnum = list.GetEnumeratorN();
  84  *              Object*         pObj = null;
  85  *              while (pEnum->MoveNext() == E_SUCCESS)
  86  *              {
  87  *                      pObj = pEnum->GetCurrent();
  88  *              }
  89  *
  90  *              delete pEnum;
  91  *
  92  *
  93  *              // Deallocates all objects
  94  *              // Because the destructor calls RemoveAll() internally, you do not need to call RemoveAll() to destroy all elements at the end.
  95  *              // list.RemoveAll();
  96  *      }
  97  * @endcode
  98  */
  99 class _OSP_EXPORT_ ArrayList
 100         : public IList
 101         , public Object
 102 {
 103 public:
 104         using IList::Add;
 105         using IList::InsertAt;
 106         using IList::Remove;
 107         using IList::RemoveAt;
 108         using IList::RemoveItems;
 109         using IList::RemoveAll;
 110         using IList::SetAt;
 111         using IList::ContainsAll;
 112         /**
 113          * This is the default constructor for this class.
 114          *
 115          * @since 2.0
 116          *
 117          * @param[in]   deleter The function pointer to type of the element deleter
 118          * @remarks             To create an owing collection, set the element deleter value as @c SingleObjectDeleter. This gives the collection the ownership of elements and the collection will destroy elements. @n
 119          *                              On the other hand, to create a non-owning collection, you do not need to set the element deleter value, as @c NoOpDeleter is the default element deleter.
 120          *                              It means that you do not transfer the ownership of elements to the collection.
 121          * @remarks             After creating an instance of the %ArrayList class, one of the Construct() methods must be called explicitly to initialize this instance.
 122          * @see                 NoOpDeleter()
 123          * @see                 SingleObjectDeleter()
 124          * @see                 ArrayDeleter()
 125          */
 126         explicit ArrayList(DeleterFunctionType deleter = NoOpDeleter);
 127
 128         /**
 129          * This destructor overrides Tizen::Base::Object::~Object().
 130          *
 131          * @since 2.0
 132          */
 133         virtual ~ArrayList(void);
 134
 135         /**
 136          * Initializes this instance of %ArrayList with the specified parameter and sets its initial capacity to the
 137          * indicated value.
 138          *
 139          * @since 2.0
 140          *
 141          * @return              An error code
 142          * @param[in]   capacity        The number of elements @n
 143          *                                              The default capacity is @c 10.
 144          * @exception   E_SUCCESS                 The method is successful.
 145          * @exception   E_INVALID_ARG     A specified input parameter is invalid, or
 146          *                                                                the specified @c capacity is negative.
 147          * @remarks             If the number of elements added to the list reaches the current capacity,
 148          *                              the capacity is automatically increased by memory reallocation.
 149          *                              Therefore, if the size of the list can be estimated,
 150          *                              specifying the initial capacity eliminates the need to perform a number of
 151          *                              resizing operations while adding elements to the list.
 152          * @see                 ArrayList()
 153          */
 154         result Construct(int capacity = DEFAULT_CAPACITY);
 155
 156
 157         /**
 158          * Initializes this instance of %ArrayList by copying the elements of the specified
 159          * @c collection. @n
 160          * The capacity of the list is the same as the number of elements copied.
 161          *
 162          * @since 2.0
 163          *
 164          * @return              An error code
 165          * @param[in]   collection      A collection to add
 166          * @exception   E_SUCCESS                       The method is successful.
 167          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 168          *                                                                      the @c collection is modified during the operation of this method.
 169          * @remarks             This method performs a shallow copy. It copies just the pointer; not the element itself.
 170          * @see                 ArrayList()
 171          */
 172         result Construct(const ICollection& collection);
 173
 174         /**
 175          * Adds the specified object to the end of this list.
 176          *
 177          * @since 2.0
 178          *
 179          * @return              An error code
 180          * @param[in]   pObj            An pointer to object to add
 181          * @exception   E_SUCCESS               The method is successful.
 182          * @exception   E_INVALID_ARG   The specified input parameter is invalid.
 183          * @remarks             This method performs a shallow copy. It adds just the pointer; not the element itself.
 184          * @see                 Remove()
 185          */
 186         virtual result Add(Object* pObj);
 187
 188
 189         /**
 190          * Adds the elements of the specified @c collection to the end of this list.
 191          *
 192          * @since 2.0
 193          *
 194          * @return              An error code
 195          * @param[in]   collection      A collection to add
 196          * @exception   E_SUCCESS                       The method is successful.
 197          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 198          *                                                                      the @c collection is modified during the operation of this method.
 199          * @remarks             This method performs a shallow copy. It adds just the pointer; not the element itself.
 200          * @see                 RemoveItems()
 201          */
 202         virtual result AddItems(const ICollection& collection);
 203
 204
 205         /**
 206          * Gets an enumerator (an instance of the IEnumerator-derived class) of this list.
 207          *
 208          * @since 2.0
 209          *
 210          * @return              An instance of the IEnumerator-derived class, @n
 211          *                              else @c null if some exception occurs
 212          * @remarks             The specific error code can be accessed using the GetLastResult() method.
 213          */
 214         virtual IEnumerator* GetEnumeratorN(void) const;
 215
 216         /**
 217          * Gets a bidirectional enumerator (an instance of the IBidirectionalEnumerator derived class) of this list.
 218          *
 219          * @since 2.0
 220          *
 221          * @return        An instance of the IBidirectionalEnumerator derived class, @n
 222          *                              else @c null if some exception occurs
 223          * @remarks      Use this method to obtain a bidirectional enumerator (an instance of the IBidirectionalEnumerator derived class)
 224          *                              to iterate over a collection (an instance of the IList derived class).
 225          *                   The specific error code can be accessed using GetLastResult() method.
 226          * @see           Tizen::Base::Collection::IBidirectionalEnumerator
 227          */
 228         virtual IBidirectionalEnumerator* GetBidirectionalEnumeratorN(void) const;
 229
 230         /**
 231          * Gets the object at the specified @c index of this list.
 232          *
 233          * @since 2.0
 234          *
 235          * @return              The object at the specified @c index of this list, @n
 236          *                              else @c null if the index is not valid
 237          * @param[in]   index   The index of the object in the calling list to read
 238          * @exception   E_SUCCESS                               The method is successful.
 239          * @exception   E_OUT_OF_RANGE                  The specified @c index is outside the bounds of the data structure, or
 240          *                                                                              the specified @c index is either equal to or greater than the number of elements or less than @c 0.
 241          * @remarks             The specific error code can be accessed using the GetLastResult() method.
 242          * @see                 SetAt()
 243          */
 244         virtual const Object* GetAt(int index) const;
 245
 246
 247         /**
 248          * Gets the object at the specified @c index of this list.
 249          *
 250          * @since 2.0
 251          *
 252          * @return              The object at the specified @c index of this list, @n
 253          *                              else @c null if the index is not valid
 254          * @param[in]   index   The index of the object to read
 255          * @exception   E_SUCCESS                               The method is successful.
 256          * @exception   E_OUT_OF_RANGE                  The specified @c index is outside the bounds of the data structure, or
 257          *                                                                              the specified @c index is either equal to or greater than the number of elements or less than @c 0.
 258          * @remarks             The specific error code can be accessed using the GetLastResult() method.
 259          * @see                 SetAt()
 260          */
 261         virtual Object* GetAt(int index);
 262
 263         /**
 264          * Gets the IList within the specified range of this list.
 265          *
 266          * @since 2.0
 267          *
 268          * @return              A pointer to IList, @n
 269          *                              else @c null if some exception occurs
 270          * @param[in]   startIndex      The starting index of the range
 271          * @param[in]   count           The number of elements to read
 272          * @exception   E_SUCCESS                               The method is successful.
 273          * @exception   E_OUT_OF_RANGE                  Either of the following conditions has occurred: @n
 274          *                                                                              - The specified index is outside the bounds of the data structure. @n
 275          *                                                                              - The specified @c startIndex is either equal to or greater than the number of elements or less than @c 0. @n
 276          *                                                                              - The @c count is greater than the number of elements starting from @c startIndex
 277          *                                                                                      or less than @c 0.
 278          * @remarks             The IList stores just the pointers to the elements in the list, not the elements themselves.
 279          *              The specific error code can be accessed using the GetLastResult() method.
 280          */
 281         virtual IList* GetItemsN(int startIndex, int count) const;
 282
 283         /**
 284          * Searches for an object in this list. @n
 285          * Gets the index of the object if found.
 286          *
 287          * @since 2.0
 288          *
 289          * @return              An error code
 290          * @param[in]   obj         The object to locate
 291          * @param[out]  index           The index of the object
 292          * @exception   E_SUCCESS               The method is successful.
 293          * @exception   E_OBJ_NOT_FOUND The specified @c obj is not found.
 294          * @see                 LastIndexOf()
 295          */
 296         virtual result IndexOf(const Object& obj, int& index) const;
 297
 298         /**
 299          * Searches for an object starting from the specified index. @n
 300          * Gets the index of the object if found.
 301          *
 302          * @since 2.0
 303          *
 304          * @return              An error code
 305          * @param[in]   obj         The object to locate
 306          * @param[in]   startIndex      The starting index for the search @n
 307          *                                                      It must be less than the number of elements.
 308          * @param[out]  index           The index of the object
 309          * @exception   E_SUCCESS                               The method is successful.
 310          * @exception   E_OUT_OF_RANGE                  The specified index is outside the bounds of the data structure, or
 311          *                                                                                      the specified @c startIndex is either equal to or greater than the number of elements or less than @c 0.
 312          * @exception   E_OBJ_NOT_FOUND         The specified @c obj is not found.
 313          * @see                 LastIndexOf()
 314          */
 315         virtual result IndexOf(const Object& obj, int startIndex, int& index) const;
 316
 317         /**
 318          * Searches for an object within the specified range. @n
 319          * Gets the index of the object if found.
 320          *
 321          * @since 2.0
 322          *
 323          * @return              An error code
 324          * @param[in]   obj         The object to locate
 325          * @param[in]   startIndex      The starting index of the range
 326          * @param[in]   count           The number of elements to read
 327          * @param[out]  index           The index of the object
 328          * @exception   E_SUCCESS                               The method is successful.
 329          * @exception   E_OUT_OF_RANGE                  Either of the following conditions has occurred: @n
 330          *                                                                              - The specified index is outside the bounds of the data structure. @n
 331          *                                                                              - The specified @c startIndex is either equal to or greater than the number of elements or less than @c 0. @n
 332          *                                                                              - The @c count is greater than the number of elements starting from @c startIndex
 333          *                                                                                      or less than @c 0.
 334          * @exception   E_OBJ_NOT_FOUND         The specified @c obj is not found.
 335          * @see                 LastIndexOf()
 336          */
 337         virtual result IndexOf(const Object& obj, int startIndex, int count, int& index) const;
 338
 339         /**
 340          * Searches for the last occurrence of an object in this list. @n
 341          * Gets the index of the object if found.
 342          *
 343          * @since 2.0
 344          *
 345          * @return              An error code
 346          * @param[in]   obj         The object to locate
 347          * @param[out]  index           The index of the last occurrence of the specified object
 348          * @exception   E_SUCCESS                       The method is successful.
 349          * @exception   E_OBJ_NOT_FOUND         The specified @c obj is not found.
 350          * @see                 IndexOf()
 351          */
 352         virtual result LastIndexOf(const Object& obj, int& index) const;
 353
 354         /**
 355          * Inserts the object at the specified location.
 356          *
 357          * @since 2.0
 358          *
 359          * @return              An error code
 360          * @param[in]   pObj        The pointer to object to insert
 361          * @param[in]   index   The index at which the object must be inserted
 362          * @exception   E_SUCCESS                               The method is successful.
 363          * @exception   E_INVALID_ARG                   The specified input parameter is invalid.
 364          * @exception   E_OUT_OF_RANGE                  The specified index is outside the bounds of the data structure, or
 365          *                                                                              the @c index is greater than the number of elements or less than @c 0.
 366          * @remarks             The elements that follow the insertion point move down to accommodate the new element.
 367          *                              If the @c index equals to the number of elements, then the new element
 368          *                              is added at the end of this list.
 369          *                              This method performs a shallow copy. It inserts just the pointer; not the element itself.
 370          * @see                 Add()
 371          * @see                 RemoveAt()
 372          */
 373         virtual result InsertAt(Object* pObj, int index);
 374
 375         /**
 376          * Inserts the elements of the collection at the specified location.
 377          *
 378          * @since 2.0
 379          *
 380          * @return              An error code
 381          * @param[in]   collection      The collection to insert
 382          * @param[in]   startIndex      The starting index at which the collection must be inserted
 383          * @exception   E_SUCCESS                               The method is successful.
 384          * @exception   E_OUT_OF_RANGE                  The specified index is outside the bounds of the data structure, or
 385          *                                                                              the @c startIndex is greater than the number of elements or less than @c 0.
 386          * @exception   E_INVALID_OPERATION             The current state of the instance prohibits the execution of the specified operation, or
 387          *                                                                              the @c collection is modified during the operation of this method.
 388          * @remarks             The elements that follow the insertion point move down to accommodate the new element.
 389          *                              If the @c startIndex equals to the number of elements then the new elements
 390          *                              are added at the end of this list.
 391          *                              This method performs a shallow copy. It inserts just the pointer; not the element itself.
 392          * @see                 RemoveItems()
 393          * @see                 AddItems()
 394          */
 395         virtual result InsertItemsFrom(const ICollection& collection, int startIndex);
 396
 397         /**
 398          * Removes the first occurrence of the specified object.
 399          *
 400          * @since 2.0
 401          *
 402          * @return              An error code
 403          * @param[in]   obj     An object to remove
 404          * @exception   E_SUCCESS               The method is successful.
 405          * @exception   E_OBJ_NOT_FOUND The specified @c obj is not found.
 406          * @see                 Add()
 407          * @see                 RemoveAt()
 408          * @see                 RemoveAll()
 409          */
 410         virtual result Remove(const Object& obj);
 411
 412         /**
 413          * Removes the object at the specified location.
 414          *
 415          * @since 2.0
 416          *
 417          * @return              An error code
 418          * @param[in]   index   The index at which the object must be removed
 419          * @exception   E_SUCCESS                               The method is successful.
 420          * @exception   E_OUT_OF_RANGE                  The specified index is outside the bounds of the data structure, or
 421          *                                                                              the specified @c index is either equal to or greater than the number of elements or less than @c 0.
 422          * @remarks             The elements that follow the deletion point move up to occupy the vacated spot.
 423          * @see                 InsertAt()
 424          * @see                 Remove()
 425          */
 426         virtual result RemoveAt(int index);
 427
 428         /**
 429          * Removes all the elements within the specified range.
 430          *
 431          * @since 2.0
 432          *
 433          * @return              An error code
 434          * @param[in]   startIndex      The starting index of the range
 435          * @param[in]   count           The number of elements to read
 436          * @exception   E_SUCCESS                               The method is successful.
 437          * @exception   E_OUT_OF_RANGE                  Either of the following conditions has occurred: @n
 438          *                                                                              - The specified index is outside the bounds of the data structure. @n
 439          *                                                                              - The specified @c startIndex is either equal to or greater than the number of elements or less than @c 0. @n
 440          *                                                                              - The @c count is greater than the number of elements starting from @c startIndex
 441          *                                                                              or less than @c 0.
 442          * @remarks             The elements that follow the deletion point move up to occupy the vacated spot.
 443          * @see                 AddItems()
 444          */
 445         virtual result RemoveItems(int startIndex, int count);
 446
 447         /**
 448          * Removes all of the elements that are in the intersection of the specified @c collection
 449          * and this list.
 450          *
 451          * @since 2.0
 452          *
 453          * @return              An error code
 454          * @param[in]   collection The collection to remove from this list
 455          * @exception   E_SUCCESS                       The method is successful.
 456          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 457          *                                                                      the @c collection is modified during the operation of this method.
 458          * @see                 Remove()
 459          * @see                 RemoveAt()
 460          */
 461         virtual result RemoveItems(const ICollection& collection);
 462
 463         /**
 464          * Removes all of the object pointers in the collection and also removes all of the objects depending on the specified element deleter.
 465          * The %RemoveAll() can be called before the collection is deleted.
 466          *
 467          * @since 2.0
 468          */
 469         virtual void RemoveAll(void);
 470
 471         /**
 472          * Replaces the object at the specified @c index with the specified object.
 473          *
 474          * @since 2.0
 475          *
 476          * @return              An error code
 477          * @param[in]   pObj            An pointer to object to set
 478          * @param[in]   index   The index at which the object must be set
 479          * @exception   E_SUCCESS                               The method is successful.
 480          * @exception   E_INVALID_ARG                   The specified input parameter is invalid.
 481          * @exception   E_OUT_OF_RANGE                  The specified index is outside the bounds of the data structure, or
 482          *                                                                              the specified @c index is either equal to or greater than the number of elements or less than @c 0.
 483          * @see                 GetAt()
 484          */
 485         virtual result SetAt(Object* pObj, int index);
 486
 487         /**
 488          * Sets the capacity of this list to the specified value.
 489          *
 490          * @since 2.0
 491          *
 492          * @return              An error code
 493          * @param[in]   newCapacity     The new capacity of this list
 494          * @exception   E_SUCCESS               The method is successful.
 495          * @exception   E_INVALID_ARG   The specified input parameter is invalid, or
 496          *                                                                the @c newCapacity is negative.
 497          * @remarks             When the new capacity is less than the current capacity, the elements
 498          *                              within the truncated memory are not destroyed.
 499          * @see                 Construct()
 500          * @see                 Trim()
 501          * @see                 GetCapacity()
 502          */
 503         virtual result SetCapacity(int newCapacity);
 504
 505         /**
 506          * Sorts the elements of this list using the comparer provided.
 507          *
 508          * @since 2.0
 509          *
 510          * @return              An error code
 511          * @param[in]   comparer        The IComparer implementation to use when comparing elements
 512          * @exception   E_SUCCESS               The method is successful.
 513          * @exception   E_INVALID_ARG   The specified input parameter is invalid.
 514          */
 515         virtual result Sort(const IComparer& comparer);
 516
 517         /**
 518          * Sets the capacity to the actual number of elements in this list.
 519          *
 520          * @since 2.0
 521          */
 522         virtual void Trim(void);
 523
 524         /**
 525          * Gets the current capacity of this list.
 526          *
 527          * @since 2.0
 528          *
 529          * @return      The current capacity of this list
 530          * @see                 SetCapacity()
 531          */
 532         virtual int GetCapacity(void) const;
 533
 534         /**
 535          * Gets the number of objects currently stored in this list.
 536          *
 537          * @since 2.0
 538          *
 539          * @return              The number of objects currently stored in this list
 540          */
 541         virtual int GetCount(void) const;
 542
 543         /**
 544          * Checks whether a list contains the specified object.
 545          *
 546          * @since 2.0
 547          *
 548          * @return              @c true if the object is present in the list, @n
 549          *                              else @c false
 550          * @param[in]   obj The object to locate
 551          * @see                 ContainsAll()
 552          */
 553         virtual bool Contains(const Object& obj) const;
 554
 555         /**
 556          * Checks whether the list contains all the elements of the specified @c collection.
 557          *
 558          * @since 2.0
 559          *
 560          * @return              @c true if the list contains all the elements of the specified @c collection, @n
 561          *                                      else @c false
 562          * @param[in]   collection      The collection to check for in the list
 563          * @exception   E_SUCCESS                       The method is successful.
 564          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 565          *                                                                      the @c collection is modified during the operation of this method.
 566          * @remarks             The specific error code can be accessed using the GetLastResult() method.
 567          * @remarks             If the given @c collection is empty, this method will return @c true.
 568          * @see                 Contains()
 569          */
 570         virtual bool ContainsAll(const ICollection& collection) const;
 571
 572         /**
 573          * Compares the specified Object instance with the calling %ArrayList instance.
 574          *
 575          * @since 2.0
 576          *
 577          * @return              @c true if the given object matches the calling List, @n
 578          *                              else @c false
 579          * @param[in]   obj The object to compare with the calling list
 580          * @remarks             This method returns @c true only if the specified object @c obj is also an instance of %ArrayList class,
 581          *                              both lists have the same size, and all the corresponding pairs of the elements in the two lists are equal.
 582          *                              In other words, the two lists are equal if they contain the same elements in the same order.
 583          */
 584         virtual bool Equals(const Object& obj) const;
 585
 586         /**
 587          * Gets the hash value of the current instance.
 588          *
 589          * @since 2.0
 590          *
 591          * @return      The hash value of the current instance
 592          * @remarks     The two Tizen::Base::Object::Equals() instances must return the same hash value. For better performance, @n
 593          *                      the used hash function must generate a random distribution for all inputs.
 594          */
 595         virtual int GetHashCode(void) const;
 596
 597         /**
 598          * Distinguish between ArrayList and LinkedList.
 599          *
 600          * @since 2.0
 601          * @return      @c true if it is an ArrayList, @n
 602          *                      else @c false if it is a LinkedList
 603          */
 604         virtual bool IsRandomAccessible(void) const
 605         {
 606                 return true;
 607         }
 608
 609         /**
 610          * Gets the element deleter of the collection.
 611          *
 612          * @since 2.0
 613          *
 614          * @return      A function pointer to the existing element deleter
 615          */
 616         virtual DeleterFunctionType GetDeleter(void) const;
 617
 618 private:
 619         /**
 620          * The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying of objects.
 621          *
 622          * @param[in]   list    The instance of the %ArrayList class to copy from
 623          */
 624         ArrayList(const ArrayList& list);
 625
 626         /**
 627          * The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit copying of objects.
 628          *
 629          * @param[in]   list    An instance of %ArrayList
 630          */
 631         ArrayList& operator =(const ArrayList& list);
 632
 633         /**
 634          * Sorts the specified sub-list.
 635          *
 636          * @return              An error code
 637          * @param[in]   startIndex The starting point of the sub-list to sort
 638          * @param[in]   endIndex The end point of the sub-list to sort
 639          * @exception   E_SUCCESS               The method is successful.
 640          * @exception   E_INVALID_ARG   A specified input parameter is invalid, or
 641          *                                                              the comparer has failed to compare the elements.
 642          */
 643         result QuickSort(int startIndex, int endIndex);
 644
 645         /**
 646          * Sets the element deleter of the collection.
 647          *
 648          * @since 2.0
 649          *
 650          * @param[in]   deleter A function pointer to the element deleter to set
 651          */
 652         virtual void SetDeleter(DeleterFunctionType deleter);
 653
 654         int __capacity;
 655         int __count;
 656         Object** __pObjArray;
 657         int __modCount;
 658         IComparer* __pComparer;
 659         static const int DEFAULT_CAPACITY = 10;
 660         DeleterFunctionType __deleter;
 661
 662         friend class _ArrayListEnumerator;
 663         friend class _ArrayListImpl;
 664         class _ArrayListImpl* __pArrayListImpl;
 665
 666 }; // ArrayList
 667
 668 }}} // Tizen::Base::Collection
 669
 670 #endif // _FBASE_COL_ARRAY_LIST_H_