inc/FBaseColIteratorT.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2013 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                FBaseColIteratorT.h
  20  * @brief               This is the header file for the %IteratorT class.
  21  *
  22  * This header file contains the declarations of the %IteratorT class.
  23  */
  24
  25 #ifndef _FBASE_COL_ITERATOR_T_H_
  26 #define _FBASE_COL_ITERATOR_T_H_
  27
  28 #include <algorithm>    // std::swap (Before C++11)
  29 #include <iterator>
  30 #include <unique_ptr.h>
  31 #include <FBaseLog.h>
  32 #include <FBaseColIList.h>
  33 #include <FBaseColIBidirectionalEnumerator.h>
  34
  35 namespace Tizen { namespace Base { namespace Collection
  36 {
  37 /**
  38  * @class       IteratorT
  39  * @brief       This class provides an iterator that is used to convert IList to STL containers.
  40  *                      StlConverter provides static methods to get this iterator from IList.
  41  *
  42  * @since       2.1
  43  *
  44  * @remarks     The %IteratorT class satisfies only requirements of C++ standard library InputIterator concept due to limitations of %Tizen Collection.
  45  *                      So, this class can be used with C++ standard library algorithms which requires only InputIterator concept for their arguments.
  46  */
  47
  48 template < typename T >
  49 class IteratorT
  50         : public std::iterator< std::input_iterator_tag, T >
  51 {
  52 public:
  53         /**
  54          * Initializes an instance of %IteratorT class.
  55          *
  56          * @since               2.1
  57          *
  58          * @param[in]   list             A reference to the IList instance to convert
  59          * @param[in]   isPostEnd        A boolean value to check the end of a list
  60          */
  61         explicit IteratorT(const IList& list, bool isPostEnd = false)
  62                 : __pList(&list)
  63                 , __isPostEnd(isPostEnd)
  64                 , __index(0)
  65                 , __pEnum(__pList->GetBidirectionalEnumeratorN())
  66                 , __currentObj(null)
  67         {
  68                 if (__pList->GetCount() != 0)
  69                 {
  70                         if (!__isPostEnd)
  71                         {
  72                                 __pEnum->MoveNext();
  73                                 __currentObj = static_cast< T >(__pEnum->GetCurrent());
  74                         }
  75                         else
  76                         {
  77                                 __index = __pList->GetCount();
  78                                 __pEnum->MovePrevious();
  79                         }
  80                 }
  81                 else
  82                 {
  83                         // Control reaches here intentionally because begin() should be equal to end()
  84                         __isPostEnd = true;
  85                 }
  86         }
  87
  88         /**
  89          * This is the copy constructor of the %IteratorT class.
  90          *
  91          * @since               2.1
  92          *
  93          * @param[in]   rhs     A reference to the %IteratorT instance
  94          */
  95         IteratorT(const IteratorT< T >& rhs)
  96                 : __pList(rhs.__pList)
  97                 , __isPostEnd(rhs.__isPostEnd)
  98                 , __index(rhs.__index)
  99                 , __pEnum(__pList->GetBidirectionalEnumeratorN())
 100                 , __currentObj(rhs.__currentObj)
 101         {
 102                 if (!__isPostEnd)
 103                 {
 104                         for (int i = 0; i <= __index; ++i)
 105                         {
 106                                 __pEnum->MoveNext();
 107                         }
 108                 }
 109                 else
 110                 {
 111                         __pEnum->MovePrevious();
 112                 }
 113         }
 114
 115         /**
 116          * This is an assignment operator of the %IteratorT class.
 117          *
 118          * @since               2.1
 119          *
 120          * @return              A reference to the %IteratorT instance
 121          * @param[in]   rhs     A reference to the %IteratorT instance on the right-hand side of the operator
 122          */
 123         IteratorT< T >& operator=(const IteratorT< T >& rhs)
 124         {
 125                 IteratorT< T > tmp(rhs);
 126                 tmp.swap(*this);
 127                 return *this;
 128         }
 129
 130         /**
 131          * This is the indirection operator for the %IteratorT class.
 132          *
 133          * @since       2.1
 134          *
 135          * @return              A T type reference
 136          */
 137         T& operator*(void) const
 138         {
 139                 AppAssertf(!__isPostEnd && __index >= 0, "It is out of range.");
 140                 return const_cast< T& >(__currentObj);
 141         }
 142
 143         /**
 144          * This is a structure dereference operator for the %IteratorT class.
 145          *
 146          * @since       2.1
 147          *
 148          * @return              A T type pointer that is equivalent to the pointer address
 149          */
 150         T* operator->(void) const
 151         {
 152                 return &(operator*());
 153         }
 154
 155         /**
 156          * Moves to the next element in the collection.
 157          *
 158          * @since               2.1
 159          *
 160          * @return              A reference to the %IteratorT type instance
 161          * @exception   E_SUCCESS                       The method is successful.
 162          * @exception   E_OUT_OF_RANGE          The iterator is outside the bounds of the list.
 163          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 164          *                                                                      the collection is modified after the enumerator is created.
 165          * @remarks             The specific error code can be accessed using GetLastResult() method.
 166          */
 167         IteratorT< T >& operator++(void)
 168         {
 169                 const int PRE_BEGIN_IDX = -1;
 170                 TryCatchResult(__index >= PRE_BEGIN_IDX, , E_OUT_OF_RANGE, "[%s] It is out of range.", GetErrorMessage(E_OUT_OF_RANGE));
 171
 172                 if (__index != PRE_BEGIN_IDX)
 173                 {
 174                         result r = __pEnum->MoveNext();
 175                         TryCatchResult(r == E_SUCCESS, __isPostEnd = true; __currentObj = null, r, "[%s] It already reached the end.", GetErrorMessage(r));
 176                 }
 177
 178                 __currentObj = static_cast< T >(__pEnum->GetCurrent());
 179
 180         CATCH:
 181                 ++__index;
 182                 return *this;
 183         }
 184
 185         /**
 186          * Moves to the next element of the collection and returns the previous state.
 187          *
 188          * @since       2.1
 189          *
 190          * @return              An %IteratorT instance
 191          * @exception   E_SUCCESS                       The method is successful.
 192          * @exception   E_OUT_OF_RANGE          The iterator is outside the bounds of the list.
 193          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 194          *                                                                      the collection is modified after the enumerator is created.
 195          * @remarks             The specific error code can be accessed using GetLastResult() method.
 196          */
 197         IteratorT< T > operator++(int)
 198         {
 199                 IteratorT< T > tempIter = *this;
 200                 operator++();
 201                 return tempIter;
 202         }
 203
 204         /**
 205          * Moves to the previous element of the collection.
 206          *
 207          * @since               2.1
 208          *
 209          * @return              A reference to the %IteratorT type instance
 210          * @exception   E_SUCCESS                       The method is successful.
 211          * @exception   E_OUT_OF_RANGE          The iterator is outside the bounds of the list.
 212          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 213          *                                                                      the collection is modified after the enumerator is created.
 214          * @remarks             The specific error code can be accessed using GetLastResult() method.
 215          */
 216         IteratorT< T >& operator--(void)
 217         {
 218                 TryCatchResult(__index <= __pList->GetCount(), , E_OUT_OF_RANGE, "[%s] It is out of range.", GetErrorMessage(E_OUT_OF_RANGE));
 219
 220                 if (!__isPostEnd)
 221                 {
 222                         result r = __pEnum->MovePrevious();
 223                         TryCatchResult(r == E_SUCCESS, __currentObj = null, r, "[%s] It already reached the front.", GetErrorMessage(r));
 224                 }
 225                 else
 226                 {
 227                         __isPostEnd = false;
 228                 }
 229
 230                 __currentObj = static_cast< T >(__pEnum->GetCurrent());
 231
 232 CATCH:
 233                 --__index;
 234                 return *this;
 235         }
 236
 237         /**
 238          * Moves to the previous element of the collection and returns the previous state.
 239          *
 240          * @since               2.1
 241          *
 242          * @return              An %IteratorT instance
 243          * @exception   E_SUCCESS                       The method is successful.
 244          * @exception   E_OUT_OF_RANGE          The iterator is outside the bounds of the list.
 245          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
 246          *                                                                      the collection is modified after the enumerator is created.
 247          * @remarks             The specific error code can be accessed using GetLastResult() method.
 248          */
 249         IteratorT< T > operator--(int)
 250         {
 251                 IteratorT< T > tempIter = *this;
 252                 operator--();
 253                 return tempIter;
 254         }
 255
 256         /**
 257          *      Checks the two %IteratorT instances for equality.
 258          *
 259          *      @since          2.1
 260          *
 261          *      @return         @c true if every member of the specified %IteratorT instance equals the calling instance's members, @n
 262          *                              else @c false
 263          *      @param[in]      rhs     A reference to the %IteratorT instance on the right-hand side of the operator
 264          */
 265         bool operator==(const IteratorT< T >& rhs) const
 266         {
 267                 if (__pList != rhs.__pList)
 268                 {
 269                         return false;
 270                 }
 271
 272                 if (__index != rhs.__index)
 273                 {
 274                         return false;
 275                 }
 276
 277                 if (__isPostEnd != rhs.__isPostEnd)
 278                 {
 279                         return false;
 280                 }
 281                 else if (__isPostEnd && rhs.__isPostEnd)
 282                 {
 283                         // In this case, __currentObj state is invalid
 284                         return true;
 285                 }
 286
 287                 // If both this->__isPostEnd and rhs.__isPostEnd are false, then reach here. This means both iterators are in the middle of the list.
 288                 return __currentObj == rhs.__currentObj;
 289         }
 290
 291         /**
 292          *      Checks the two %IteratorT instances for inequality.
 293          *
 294          *      @since          2.1
 295          *
 296          *      @return         @c true if any member of the specified %IteratorT instance is not equal to the calling instance's members, @n
 297          *                              else @c false
 298          *      @param[in]      rhs     A reference to the %IteratorT instance on the right-hand side of the operator
 299          */
 300         bool operator!=(const IteratorT< T >& rhs) const
 301         {
 302                 return !operator==(rhs);
 303         }
 304
 305         /**
 306          *      Swaps values of two %IteratorT instances.
 307          *
 308          *      @since          2.1
 309          *
 310          *      @param[in]      rhs     A reference to a %IteratorT instance to swap
 311          */
 312         void swap(IteratorT< T >& rhs)
 313         {
 314                 std::swap(__pList, rhs.__pList);
 315                 std::swap(__isPostEnd, rhs.__isPostEnd);
 316                 std::swap(__index, rhs.__index);
 317                 std::swap(__pEnum, rhs.__pEnum);
 318                 std::swap(__currentObj, rhs.__currentObj);
 319         }
 320
 321 private:
 322         const IList* __pList;
 323         bool __isPostEnd;
 324         int __index;
 325         std::unique_ptr< IBidirectionalEnumerator > __pEnum;
 326         T __currentObj;
 327 }; // IteratorT
 328
 329 }}} // Tizen::Base::Collection
 330
 331 #endif //_FBASE_COL_ITERATOR_T_H_