inc/FBaseColArrayList.h

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