00001 /* iterator_to_const and const_iterator_to_const class implementations: 00002 inline functions. 00003 Copyright (C) 2001-2008 Roberto Bagnara <bagnara@cs.unipr.it> 00004 00005 This file is part of the Parma Polyhedra Library (PPL). 00006 00007 The PPL is free software; you can redistribute it and/or modify it 00008 under the terms of the GNU General Public License as published by the 00009 Free Software Foundation; either version 3 of the License, or (at your 00010 option) any later version. 00011 00012 The PPL is distributed in the hope that it will be useful, but WITHOUT 00013 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 00014 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 00015 for more details. 00016 00017 You should have received a copy of the GNU General Public License 00018 along with this program; if not, write to the Free Software Foundation, 00019 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA. 00020 00021 For the most up-to-date information see the Parma Polyhedra Library 00022 site: http://www.cs.unipr.it/ppl/ . */ 00023 00024 #ifndef PPL_iterator_to_const_inlines_hh 00025 #define PPL_iterator_to_const_inlines_hh 1 00026 00027 namespace Parma_Polyhedra_Library { 00028 00029 template <typename Container> 00030 inline 00031 iterator_to_const<Container>::iterator_to_const() 00032 : base() { 00033 } 00034 00035 template <typename Container> 00036 inline 00037 iterator_to_const<Container>::iterator_to_const(const iterator_to_const& y) 00038 : base(y.base) { 00039 } 00040 00041 template <typename Container> 00042 inline 00043 iterator_to_const<Container>::iterator_to_const(const Base& b) 00044 : base(b) { 00045 } 00046 00047 template <typename Container> 00048 inline typename iterator_to_const<Container>::reference 00049 iterator_to_const<Container>::operator*() const { 00050 return *base; 00051 } 00052 00053 template <typename Container> 00054 inline typename iterator_to_const<Container>::pointer 00055 iterator_to_const<Container>::operator->() const { 00056 return &*base; 00057 } 00058 00059 template <typename Container> 00060 inline iterator_to_const<Container>& 00061 iterator_to_const<Container>::operator++() { 00062 ++base; 00063 return *this; 00064 } 00065 00066 template <typename Container> 00067 inline iterator_to_const<Container> 00068 iterator_to_const<Container>::operator++(int) { 00069 iterator_to_const tmp = *this; 00070 operator++(); 00071 return tmp; 00072 } 00073 00074 template <typename Container> 00075 inline iterator_to_const<Container>& 00076 iterator_to_const<Container>::operator--() { 00077 --base; 00078 return *this; 00079 } 00080 00081 template <typename Container> 00082 inline iterator_to_const<Container> 00083 iterator_to_const<Container>::operator--(int) { 00084 iterator_to_const tmp = *this; 00085 operator--(); 00086 return tmp; 00087 } 00088 00089 template <typename Container> 00090 inline bool 00091 iterator_to_const<Container>::operator==(const iterator_to_const& y) const { 00092 return base == y.base; 00093 } 00094 00095 template <typename Container> 00096 inline bool 00097 iterator_to_const<Container>::operator!=(const iterator_to_const& y) const { 00098 return !operator==(y); 00099 } 00100 00101 template <typename Container> 00102 inline 00103 const_iterator_to_const<Container>::const_iterator_to_const() 00104 : base() { 00105 } 00106 00107 template <typename Container> 00108 inline 00109 const_iterator_to_const<Container> 00110 ::const_iterator_to_const(const const_iterator_to_const& y) 00111 : base(y.base) { 00112 } 00113 00114 template <typename Container> 00115 inline 00116 const_iterator_to_const<Container>::const_iterator_to_const(const Base& b) 00117 : base(b) { 00118 } 00119 00120 template <typename Container> 00121 inline typename const_iterator_to_const<Container>::reference 00122 const_iterator_to_const<Container>::operator*() const { 00123 return *base; 00124 } 00125 00126 template <typename Container> 00127 inline typename const_iterator_to_const<Container>::pointer 00128 const_iterator_to_const<Container>::operator->() const { 00129 return &*base; 00130 } 00131 00132 template <typename Container> 00133 inline const_iterator_to_const<Container>& 00134 const_iterator_to_const<Container>::operator++() { 00135 ++base; 00136 return *this; 00137 } 00138 00139 template <typename Container> 00140 inline const_iterator_to_const<Container> 00141 const_iterator_to_const<Container>::operator++(int) { 00142 const_iterator_to_const tmp = *this; 00143 operator++(); 00144 return tmp; 00145 } 00146 00147 template <typename Container> 00148 inline const_iterator_to_const<Container>& 00149 const_iterator_to_const<Container>::operator--() { 00150 --base; 00151 return *this; 00152 } 00153 00154 template <typename Container> 00155 inline const_iterator_to_const<Container> 00156 const_iterator_to_const<Container>::operator--(int) { 00157 const_iterator_to_const tmp = *this; 00158 operator--(); 00159 return tmp; 00160 } 00161 00162 template <typename Container> 00163 inline bool 00164 const_iterator_to_const<Container> 00165 ::operator==(const const_iterator_to_const& y) const { 00166 return base == y.base; 00167 } 00168 00169 template <typename Container> 00170 inline bool 00171 const_iterator_to_const<Container> 00172 ::operator!=(const const_iterator_to_const& y) const { 00173 return !operator==(y); 00174 } 00175 00176 template <typename Container> 00177 inline 00178 const_iterator_to_const<Container> 00179 ::const_iterator_to_const(const iterator_to_const<Container>& y) 00180 : base(y.base) { 00181 } 00182 00184 template <typename Container> 00185 inline bool 00186 operator==(const iterator_to_const<Container>& x, 00187 const const_iterator_to_const<Container>& y) { 00188 return const_iterator_to_const<Container>(x).operator==(y); 00189 } 00190 00192 template <typename Container> 00193 inline bool 00194 operator!=(const iterator_to_const<Container>& x, 00195 const const_iterator_to_const<Container>& y) { 00196 return !(x == y); 00197 } 00198 00199 } // namespace Parma_Polyhedra_Library 00200 00201 #endif // !defined(PPL_iterator_to_const_inlines_hh)