00001 #ifndef _theplu_yat_utility_range_
00002 #define _theplu_yat_utility_range_
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <algorithm>
00026
00027 namespace theplu {
00028 namespace yat {
00029 namespace utility {
00030
00040 template<typename T>
00041 class Range
00042 {
00043 public:
00047 typedef T iterator_type;
00048
00052
00053 Range(void);
00054
00058 Range(T first, T last);
00059
00067 T begin(void) const;
00068
00072 T end(void) const;
00073
00074
00082 Range& operator=(const Range&);
00083
00084 private:
00085
00086
00087
00088 T first_;
00089 T last_;
00090 };
00091
00098 template<typename T1, typename T2>
00099 bool operator==(const Range<T1>&, const Range<T2>&);
00100
00106 template<typename T1, typename T2>
00107 bool operator!=(const Range<T1>&, const Range<T2>&);
00108
00118 template<typename T1, typename T2>
00119 bool operator<(const Range<T1>& lhs, const Range<T2>& rhs);
00120
00126 template<typename T1, typename T2>
00127 bool operator<=(const Range<T1>& lhs, const Range<T2>& rhs);
00128
00134 template<typename T1, typename T2>
00135 bool operator>(const Range<T1>&, const Range<T2>&);
00136
00142 template<typename T1, typename T2>
00143 bool operator>=(const Range<T1>&, const Range<T2>&);
00144
00145
00146
00147 template<typename T>
00148 Range<T>::Range(void){}
00149
00150 template<typename T>
00151 Range<T>::Range(T first, T last)
00152 : first_(first), last_(last)
00153 {}
00154
00155 template<typename T>
00156 T Range<T>::begin(void) const
00157 { return first_; }
00158
00159
00160 template<typename T>
00161 T Range<T>::end(void) const
00162 { return last_; }
00163
00164
00165 template<typename T>
00166 Range<T>& Range<T>::operator=(const Range<T>& rhs)
00167 {
00168 first_ = rhs.begin();
00169 last_ = rhs.end();
00170 return *this;
00171 }
00172
00173
00174 template<typename T1, typename T2>
00175 bool operator==(const Range<T1>& lhs, const Range<T2>& rhs)
00176 {
00177
00178
00179 T1 first1(lhs.begin());
00180 T1 last1(lhs.end());
00181 T2 first2(rhs.begin());
00182 T2 last2(rhs.end());
00183 while (first1 != last1 && first2 != last2) {
00184 if (*first1 != *first2)
00185 return false;
00186 ++first1;
00187 ++first2;
00188 }
00189
00190 return first1==last1 && first2==last2;
00191 }
00192
00193
00194 template<typename T1, typename T2>
00195 bool operator!=(const Range<T1>& lhs, const Range<T2>& rhs)
00196 {
00197 return ! (lhs==rhs);
00198 }
00199
00200
00201 template<typename T1, typename T2>
00202 bool operator<(const Range<T1>& lhs, const Range<T2>& rhs)
00203 {
00204 return std::lexicographical_compare(lhs.begin(), lhs.end(),
00205 rhs.begin(), rhs.end());
00206 }
00207
00208
00209 template<typename T1, typename T2>
00210 bool operator>(const Range<T1>& lhs, const Range<T2>& rhs)
00211 {
00212 return rhs < lhs;
00213 }
00214
00215
00216 template<typename T1, typename T2>
00217 bool operator<=(const Range<T1>& lhs, const Range<T2>& rhs)
00218 {
00219 return ! (rhs<lhs);
00220 }
00221
00222
00223 template<typename T1, typename T2>
00224 bool operator>=(const Range<T1>& lhs, const Range<T2>& rhs)
00225 {
00226 return ! (lhs<rhs);
00227 }
00228
00229 }}}
00230
00231 #endif