Src/DirItemIterator.h

   1 /**
   2  *  @file DirItemIterator.h
   3  *
   4  *  @brief Declaration DirItemIterator classes.
   5  */
   6 // ID line follows -- this is updated by SVN
   7 // $Id$
   8
   9 #pragma once
  10
  11 #include <iterator>
  12 #include <utility>
  13 #include "IListCtrl.h"
  14
  15 class DIFFITEM;
  16
  17 class DirItemWithIndexIterator : public std::iterator<std::forward_iterator_tag, std::pair<int, DIFFITEM *> >
  18 {
  19 public:
  20         explicit DirItemWithIndexIterator(IListCtrl *pList, int sel = -1, bool selected = false, bool reverse = false) :
  21           m_pList(pList), m_sel(sel), m_selected(selected), m_reverse(reverse)
  22         {
  23                 if (m_sel == -1)
  24                 {
  25                         if (m_reverse)
  26                         {
  27                                 int last = m_pList->GetRowCount() - 1;
  28                                 if (!m_selected || m_pList->IsSelectedItem(last))
  29                                         m_sel = last;
  30                                 else
  31                                         m_sel = m_pList->GetNextItem(last, m_selected, m_reverse);
  32                         }
  33                         else
  34                                 m_sel = m_pList->GetNextItem(-1, m_selected, m_reverse);
  35                 }
  36                 if (m_sel != -1)
  37                 {
  38                         if (m_pList->GetItemData(m_sel) == reinterpret_cast<void *>((uintptr_t)-1L))
  39                         {
  40                                 if (m_reverse && m_sel == 0)
  41                                         m_sel = -1;
  42                                 else
  43                                         m_sel = m_pList->GetNextItem(m_sel, m_selected, m_reverse);
  44                         }
  45                 }
  46         }
  47
  48         DirItemWithIndexIterator() : m_pList(NULL), m_sel(-1), m_selected(false), m_reverse(false)
  49         {
  50         }
  51
  52         ~DirItemWithIndexIterator() {}
  53
  54         DirItemWithIndexIterator& operator=(const DirItemWithIndexIterator& it)
  55         {
  56                 m_sel = it.m_sel;
  57                 m_pList = it.m_pList;
  58                 m_selected = it.m_selected;
  59                 m_reverse = it.m_reverse;
  60                 return *this;
  61         }
  62
  63         DirItemWithIndexIterator& operator++()
  64         {
  65                 m_sel = m_pList->GetNextItem(m_sel, m_selected, m_reverse);
  66                 return *this;
  67         }
  68
  69         std::pair<int, DIFFITEM *> operator*()
  70         {
  71                 return std::make_pair(m_sel, reinterpret_cast<DIFFITEM *>(m_pList->GetItemData(m_sel)));
  72         }
  73
  74         bool operator==(const DirItemWithIndexIterator& it) const
  75         {
  76                 return m_sel == it.m_sel;
  77         }
  78
  79         bool operator!=(const DirItemWithIndexIterator& it) const
  80         {
  81                 return m_sel != it.m_sel;
  82         }
  83
  84         bool m_selected;
  85         bool m_reverse;
  86         int m_sel;
  87
  88 private:
  89         IListCtrl *m_pList;
  90 };
  91
  92 class DirItemIterator : public std::iterator<std::forward_iterator_tag, DIFFITEM*>
  93 {
  94 public:
  95         explicit DirItemIterator(IListCtrl *pList, int sel = -1, bool selected = false, bool reverse = false) :
  96           m_pList(pList), m_sel(sel), m_selected(selected), m_reverse(reverse), m_pdi(nullptr)
  97         {
  98                 if (m_sel == -1)
  99                 {
 100                         if (m_reverse)
 101                         {
 102                                 int last = m_pList->GetRowCount() - 1;
 103                                 if (!m_selected || m_pList->IsSelectedItem(last))
 104                                         m_sel = last;
 105                                 else
 106                                         m_sel = m_pList->GetNextItem(last, m_selected, m_reverse);
 107                         }
 108                         else
 109                                 m_sel = m_pList->GetNextItem(-1, m_selected, m_reverse);
 110                 }
 111                 if (m_sel != -1)
 112                 {
 113                         m_pdi = reinterpret_cast<const DIFFITEM *>(m_pList->GetItemData(m_sel));
 114                         if (m_pdi == reinterpret_cast<const DIFFITEM *>(-1L))
 115                         {
 116                                 if (m_reverse && m_sel == 0)
 117                                         m_sel = -1;
 118                                 else
 119                                 {
 120                                         m_sel = m_pList->GetNextItem(m_sel, m_selected, m_reverse);
 121                                         m_pdi = reinterpret_cast<const DIFFITEM *>(m_pList->GetItemData(m_sel));
 122                                 }
 123                         }
 124                         else if (m_pdi == nullptr)
 125                         {
 126                                 m_sel = -1;
 127                         }
 128                 }
 129         }
 130
 131         DirItemIterator() : m_pList(nullptr), m_sel(-1), m_selected(false), m_reverse(false), m_pdi(nullptr)
 132         {
 133         }
 134
 135         ~DirItemIterator() {}
 136
 137         DirItemIterator& operator=(const DirItemIterator& it)
 138         {
 139                 m_sel = it.m_sel;
 140                 m_pList = it.m_pList;
 141                 m_pdi = it.m_pdi;
 142                 m_selected = it.m_selected;
 143                 m_reverse = it.m_reverse;
 144                 return *this;
 145         }
 146
 147         DirItemIterator& operator++()
 148         {
 149                 if (m_reverse && m_sel <= 0)
 150                 {
 151                         m_sel = -1;
 152                         m_pdi = reinterpret_cast<const DIFFITEM *>(-1L);
 153                 }
 154                 else
 155                 {
 156                         m_sel = m_pList->GetNextItem(m_sel, m_selected, m_reverse);
 157                         m_pdi = reinterpret_cast<const DIFFITEM *>(m_pList->GetItemData(m_sel));
 158                         if (m_pdi == reinterpret_cast<const DIFFITEM *>(-1L))
 159                                 m_sel = -1;
 160                 }
 161                 return *this;
 162         }
 163
 164         DIFFITEM& operator*()
 165         {
 166                 return *const_cast<DIFFITEM *>(m_pdi);
 167         }
 168
 169         const DIFFITEM& operator*() const
 170         {
 171                 return *m_pdi;
 172         }
 173
 174         bool operator==(const DirItemIterator& it) const
 175         {
 176                 return m_sel == it.m_sel;
 177         }
 178
 179         bool operator!=(const DirItemIterator& it) const
 180         {
 181                 return m_sel != it.m_sel;
 182         }
 183
 184         bool m_selected;
 185         bool m_reverse;
 186         int m_sel;
 187         const DIFFITEM *m_pdi;
 188
 189 private:
 190         IListCtrl *m_pList;
 191 };