sd/source/ui/toolpanel/ConstrainedIterator.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ConstrainedIterator.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 // This is a definition file of a template class.  It is therefore
  35 // included by other files and thus has to be guarded against multiple
  36 // inclusion.
  37
  38 #ifndef SD_TOOLPANEL_CONSTRAINED_ITERATOR_CXX
  39 #define SD_TOOLPANEL_CONSTRAINED_ITERATOR_CXX
  40
  41 namespace sd { namespace toolpanel {
  42
  43
  44 template <class Container>
  45 ConstrainedIterator<Container>::value_type&
  46     ConstrainedIterator<Container>::operator* (void)
  47 {
  48     return *maIterator;
  49 }
  50
  51
  52
  53
  54 template <class Container>
  55 const ConstrainedIterator<Container>::value_type&
  56     ConstrainedIterator<Container>::operator* (void)
  57     const
  58 {
  59     return *maIterator;
  60 }
  61
  62
  63
  64
  65 template <class Container>
  66 ConstrainedIterator<Container>::value_type&
  67     ConstrainedIterator<Container>::operator-> (void)
  68 {
  69     return *maIterator;
  70 }
  71
  72
  73
  74
  75 template <class Container>
  76 const ConstrainedIterator<Container>::value_type&
  77     ConstrainedIterator<Container>::operator-> (void)
  78     const
  79 {
  80     return *maIterator;
  81 }
  82
  83
  84
  85
  86
  87 template <class Container>
  88 ConstrainedIterator<Container>
  89     ::ConstrainedIterator (void)
  90     : mpContainer (NULL)
  91 {
  92 }
  93
  94
  95
  96
  97 template <class Container>
  98 ConstrainedIterator<Container>::ConstrainedIterator (
  99     const Container& rContainer,
 100     const Container::iterator& rIterator)
 101     : mpContainer(&rContainer),
 102       maIterator (rIterator),
 103       mpConstraint (NULL)
 104 {
 105     AdvanceToNextValidElement();
 106 }
 107
 108
 109
 110
 111 template <class Container>
 112 ConstrainedIterator<Container>::ConstrainedIterator (
 113     const Container& rContainer,
 114     const Container::iterator& rIterator,
 115     const Constraint<Container>& rConstraint)
 116     : mpContainer(&rContainer),
 117       maIterator (rIterator),
 118       mpConstraint (&rConstraint)
 119 {
 120     AdvanceToNextValidElement();
 121 }
 122
 123
 124
 125
 126 template <class Container>
 127 ConstrainedIterator<Container>::ConstrainedIterator (
 128     const ConstrainedIterator& rIterator)
 129     : mpContainer (rIterator.mpContainer),
 130       maIterator (rIterator.maIterator),
 131       mpConstraint (rIterator.mpConstraint)
 132 {
 133     // Everything has been done in the initializer
 134 }
 135
 136
 137
 138
 139 template <class Container>
 140 ConstrainedIterator<Container>&
 141     ConstrainedIterator<Container>
 142     ::operator= (const ConstrainedIterator& rIterator)
 143 {
 144     mpContainer = rIterator.mpContainer;
 145     maIterator = rIterator.maIterator;
 146     mpConstraint = rIterator.mpConstraint;
 147
 148     AdvanceToNextValidElement();
 149
 150     return *this;
 151 }
 152
 153
 154
 155
 156 template <class Container>
 157 bool ConstrainedIterator<Container>::operator== (
 158     const ConstrainedIterator& aIterator) const
 159 {
 160     return ! operator!=(aIterator);
 161 }
 162
 163
 164
 165
 166 template <class Container>
 167 bool ConstrainedIterator<Container>::operator!= (
 168     const ConstrainedIterator& aIterator) const
 169 {
 170     return maIterator != aIterator.maIterator;
 171 }
 172
 173
 174
 175
 176 template <class Container>
 177 ConstrainedIterator<Container>&
 178     ConstrainedIterator<Container>::operator++ (void)
 179 {
 180     maIterator++;
 181     AdvanceToNextValidElement();
 182     return *this;
 183 }
 184
 185
 186
 187
 188 template <class Container>
 189 ConstrainedIterator<Container>
 190     ConstrainedIterator<Container>::operator++ (int)
 191 {
 192     ConstrainedIterator aIterator (*this);
 193     ++(*this);
 194     return aIterator;
 195 }
 196
 197
 198
 199
 200 template <class Container>
 201 ConstrainedIterator<Container>&
 202     ConstrainedIterator<Container>::operator-- (void)
 203 {
 204     maIterator--;
 205     AdvanceToPreviousValidElement();
 206     return *this;
 207 }
 208
 209
 210
 211
 212 template <class Container>
 213 ConstrainedIterator<Container>
 214     ConstrainedIterator<Container>::operator-- (int)
 215 {
 216     ConstrainedIterator aIterator (*this);
 217     --(*this);
 218     return aIterator;
 219 }
 220
 221
 222
 223
 224 template <class Container>
 225 ConstrainedIterator<Container>
 226     ConstrainedIterator<Container>::operator+ (int nValue) const
 227 {
 228     return ConstrainedIterator (*mpContainer, maIterator+nValue);
 229 }
 230
 231
 232
 233 template <class Container>
 234 ConstrainedIterator<Container>
 235     ConstrainedIterator<Container>::operator- (int nValue) const
 236 {
 237     return ConstrainedIterator (*mpContainer, maIterator-nValue);
 238 }
 239
 240
 241
 242 template <class Container>
 243 void ConstrainedIterator<Container>::AdvanceToNextValidElement (void)
 244 {
 245     if (mpContainer!=NULL && mpConstraint!=NULL)
 246     {
 247         while (maIterator != mpContainer->end()
 248             && ! mpConstraint->operator()(*mpContainer, maIterator))
 249             ++maIterator;
 250     }
 251 }
 252
 253
 254
 255
 256 template <class Container>
 257 void ConstrainedIterator<Container>::AdvanceToPreviousValidElement (void)
 258 {
 259     if (mpContainer!=NULL && mpConstraint!=NULL)
 260     {
 261         while (maIterator != mpContainer->begin()
 262             && ! mpConstraint->operator()(*mpContainer, maIterator))
 263             --maIterator;
 264     }
 265 }
 266
 267
 268 } } // end of namespace ::sd::toolpanel
 269
 270 #endif