1 // 2 // Copyright (c) 2009-2011 Artyom Beilis (Tonkikh) 3 // 4 // Distributed under the Boost Software License, Version 1.0. (See 5 // accompanying file LICENSE_1_0.txt or copy at 6 // http://www.boost.org/LICENSE_1_0.txt) 7 // 8 #ifndef BOOST_LOCALE_BOUNDARY_SEGMENT_HPP_INCLUDED 9 #define BOOST_LOCALE_BOUNDARY_SEGMENT_HPP_INCLUDED 10 #include <boost/locale/config.hpp> 11 #ifdef BOOST_MSVC 12 # pragma warning(push) 13 # pragma warning(disable : 4275 4251 4231 4660) 14 #endif 15 #include <locale> 16 #include <string> 17 #include <iosfwd> 18 #include <iterator> 19 20 21 namespace boost { 22 namespace locale { 23 namespace boundary { 24 /// \cond INTERNAL 25 namespace details { 26 template<typename LeftIterator,typename RightIterator> compare_text(LeftIterator l_begin,LeftIterator l_end,RightIterator r_begin,RightIterator r_end)27 int compare_text(LeftIterator l_begin,LeftIterator l_end,RightIterator r_begin,RightIterator r_end) 28 { 29 typedef LeftIterator left_iterator; 30 typedef typename std::iterator_traits<left_iterator>::value_type char_type; 31 typedef std::char_traits<char_type> traits; 32 while(l_begin!=l_end && r_begin!=r_end) { 33 char_type lchar = *l_begin++; 34 char_type rchar = *r_begin++; 35 if(traits::eq(lchar,rchar)) 36 continue; 37 if(traits::lt(lchar,rchar)) 38 return -1; 39 else 40 return 1; 41 } 42 if(l_begin==l_end && r_begin==r_end) 43 return 0; 44 if(l_begin==l_end) 45 return -1; 46 else 47 return 1; 48 } 49 50 51 template<typename Left,typename Right> compare_text(Left const & l,Right const & r)52 int compare_text(Left const &l,Right const &r) 53 { 54 return compare_text(l.begin(),l.end(),r.begin(),r.end()); 55 } 56 57 template<typename Left,typename Char> compare_string(Left const & l,Char const * begin)58 int compare_string(Left const &l,Char const *begin) 59 { 60 Char const *end = begin; 61 while(*end!=0) 62 end++; 63 return compare_text(l.begin(),l.end(),begin,end); 64 } 65 66 template<typename Right,typename Char> compare_string(Char const * begin,Right const & r)67 int compare_string(Char const *begin,Right const &r) 68 { 69 Char const *end = begin; 70 while(*end!=0) 71 end++; 72 return compare_text(begin,end,r.begin(),r.end()); 73 } 74 75 } 76 /// \endcond 77 78 /// 79 /// \addtogroup boundary 80 /// @{ 81 82 /// 83 /// \brief a segment object that represents a pair of two iterators that define the range where 84 /// this segment exits and a rule that defines it. 85 /// 86 /// This type of object is dereferenced by the iterators of segment_index. Using a rule() member function 87 /// you can get a specific rule this segment was selected with. For example, when you use 88 /// word boundary analysis, you can check if the specific word contains Kana letters by checking (rule() & \ref word_kana)!=0 89 /// For a sentence analysis you can check if the sentence is selected because a sentence terminator is found (\ref sentence_term) or 90 /// there is a line break (\ref sentence_sep). 91 /// 92 /// This object can be automatically converted to std::basic_string with the same type of character. It is also 93 /// valid range that has begin() and end() member functions returning iterators on the location of the segment. 94 /// 95 /// \see 96 /// 97 /// - \ref segment_index 98 /// - \ref boundary_point 99 /// - \ref boundary_point_index 100 /// 101 template<typename IteratorType> 102 class segment : public std::pair<IteratorType,IteratorType> { 103 public: 104 /// 105 /// The type of the underlying character 106 /// 107 typedef typename std::iterator_traits<IteratorType>::value_type char_type; 108 /// 109 /// The type of the string it is converted to 110 /// 111 typedef std::basic_string<char_type> string_type; 112 /// 113 /// The value that iterators return - the character itself 114 /// 115 typedef char_type value_type; 116 /// 117 /// The iterator that allows to iterate the range 118 /// 119 typedef IteratorType iterator; 120 /// 121 /// The iterator that allows to iterate the range 122 /// 123 typedef IteratorType const_iterator; 124 /// 125 /// The type that represent a difference between two iterators 126 /// 127 typedef typename std::iterator_traits<IteratorType>::difference_type difference_type; 128 129 /// 130 /// Default constructor 131 /// segment()132 segment() {} 133 /// 134 /// Create a segment using two iterators and a rule that represents this point 135 /// segment(iterator b,iterator e,rule_type r)136 segment(iterator b,iterator e,rule_type r) : 137 std::pair<IteratorType,IteratorType>(b,e), 138 rule_(r) 139 { 140 } 141 /// 142 /// Set the start of the range 143 /// begin(iterator const & v)144 void begin(iterator const &v) 145 { 146 this->first = v; 147 } 148 /// 149 /// Set the end of the range 150 /// end(iterator const & v)151 void end(iterator const &v) 152 { 153 this->second = v; 154 } 155 156 /// 157 /// Get the start of the range 158 /// begin() const159 IteratorType begin() const 160 { 161 return this->first; 162 } 163 /// 164 /// Set the end of the range 165 /// end() const166 IteratorType end() const 167 { 168 return this->second; 169 } 170 171 /// 172 /// Convert the range to a string automatically 173 /// 174 template <class T, class A> operator std::basic_string<char_type,T,A>() const175 operator std::basic_string<char_type, T, A> ()const 176 { 177 return std::basic_string<char_type, T, A>(this->first, this->second); 178 } 179 180 /// 181 /// Create a string from the range explicitly 182 /// str() const183 string_type str() const 184 { 185 return string_type(begin(),end()); 186 } 187 188 /// 189 /// Get the length of the text chunk 190 /// 191 length() const192 size_t length() const 193 { 194 return std::distance(begin(),end()); 195 } 196 197 /// 198 /// Check if the segment is empty 199 /// empty() const200 bool empty() const 201 { 202 return begin() == end(); 203 } 204 205 /// 206 /// Get the rule that is used for selection of this segment. 207 /// rule() const208 rule_type rule() const 209 { 210 return rule_; 211 } 212 /// 213 /// Set a rule that is used for segment selection 214 /// rule(rule_type r)215 void rule(rule_type r) 216 { 217 rule_ = r; 218 } 219 220 // make sure we override std::pair's operator== 221 222 /// Compare two segments operator ==(segment const & other)223 bool operator==(segment const &other) 224 { 225 return details::compare_text(*this,other) == 0; 226 } 227 228 /// Compare two segments operator !=(segment const & other)229 bool operator!=(segment const &other) 230 { 231 return details::compare_text(*this,other) != 0; 232 } 233 234 private: 235 rule_type rule_; 236 237 }; 238 239 240 /// Compare two segments 241 template<typename IteratorL,typename IteratorR> operator ==(segment<IteratorL> const & l,segment<IteratorR> const & r)242 bool operator==(segment<IteratorL> const &l,segment<IteratorR> const &r) 243 { 244 return details::compare_text(l,r) == 0; 245 } 246 /// Compare two segments 247 template<typename IteratorL,typename IteratorR> operator !=(segment<IteratorL> const & l,segment<IteratorR> const & r)248 bool operator!=(segment<IteratorL> const &l,segment<IteratorR> const &r) 249 { 250 return details::compare_text(l,r) != 0; 251 } 252 253 /// Compare two segments 254 template<typename IteratorL,typename IteratorR> operator <(segment<IteratorL> const & l,segment<IteratorR> const & r)255 bool operator<(segment<IteratorL> const &l,segment<IteratorR> const &r) 256 { 257 return details::compare_text(l,r) < 0; 258 } 259 /// Compare two segments 260 template<typename IteratorL,typename IteratorR> operator <=(segment<IteratorL> const & l,segment<IteratorR> const & r)261 bool operator<=(segment<IteratorL> const &l,segment<IteratorR> const &r) 262 { 263 return details::compare_text(l,r) <= 0; 264 } 265 /// Compare two segments 266 template<typename IteratorL,typename IteratorR> operator >(segment<IteratorL> const & l,segment<IteratorR> const & r)267 bool operator>(segment<IteratorL> const &l,segment<IteratorR> const &r) 268 { 269 return details::compare_text(l,r) > 0; 270 } 271 /// Compare two segments 272 template<typename IteratorL,typename IteratorR> operator >=(segment<IteratorL> const & l,segment<IteratorR> const & r)273 bool operator>=(segment<IteratorL> const &l,segment<IteratorR> const &r) 274 { 275 return details::compare_text(l,r) >= 0; 276 } 277 278 /// Compare string and segment 279 template<typename CharType,typename Traits,typename Alloc,typename IteratorR> operator ==(std::basic_string<CharType,Traits,Alloc> const & l,segment<IteratorR> const & r)280 bool operator==(std::basic_string<CharType,Traits,Alloc> const &l,segment<IteratorR> const &r) 281 { 282 return details::compare_text(l,r) == 0; 283 } 284 /// Compare string and segment 285 template<typename CharType,typename Traits,typename Alloc,typename IteratorR> operator !=(std::basic_string<CharType,Traits,Alloc> const & l,segment<IteratorR> const & r)286 bool operator!=(std::basic_string<CharType,Traits,Alloc> const &l,segment<IteratorR> const &r) 287 { 288 return details::compare_text(l,r) != 0; 289 } 290 291 /// Compare string and segment 292 template<typename CharType,typename Traits,typename Alloc,typename IteratorR> operator <(std::basic_string<CharType,Traits,Alloc> const & l,segment<IteratorR> const & r)293 bool operator<(std::basic_string<CharType,Traits,Alloc> const &l,segment<IteratorR> const &r) 294 { 295 return details::compare_text(l,r) < 0; 296 } 297 /// Compare string and segment 298 template<typename CharType,typename Traits,typename Alloc,typename IteratorR> operator <=(std::basic_string<CharType,Traits,Alloc> const & l,segment<IteratorR> const & r)299 bool operator<=(std::basic_string<CharType,Traits,Alloc> const &l,segment<IteratorR> const &r) 300 { 301 return details::compare_text(l,r) <= 0; 302 } 303 /// Compare string and segment 304 template<typename CharType,typename Traits,typename Alloc,typename IteratorR> operator >(std::basic_string<CharType,Traits,Alloc> const & l,segment<IteratorR> const & r)305 bool operator>(std::basic_string<CharType,Traits,Alloc> const &l,segment<IteratorR> const &r) 306 { 307 return details::compare_text(l,r) > 0; 308 } 309 /// Compare string and segment 310 template<typename CharType,typename Traits,typename Alloc,typename IteratorR> operator >=(std::basic_string<CharType,Traits,Alloc> const & l,segment<IteratorR> const & r)311 bool operator>=(std::basic_string<CharType,Traits,Alloc> const &l,segment<IteratorR> const &r) 312 { 313 return details::compare_text(l,r) >= 0; 314 } 315 316 /// Compare string and segment 317 template<typename Iterator,typename CharType,typename Traits,typename Alloc> operator ==(segment<Iterator> const & l,std::basic_string<CharType,Traits,Alloc> const & r)318 bool operator==(segment<Iterator> const &l,std::basic_string<CharType,Traits,Alloc> const &r) 319 { 320 return details::compare_text(l,r) == 0; 321 } 322 /// Compare string and segment 323 template<typename Iterator,typename CharType,typename Traits,typename Alloc> operator !=(segment<Iterator> const & l,std::basic_string<CharType,Traits,Alloc> const & r)324 bool operator!=(segment<Iterator> const &l,std::basic_string<CharType,Traits,Alloc> const &r) 325 { 326 return details::compare_text(l,r) != 0; 327 } 328 329 /// Compare string and segment 330 template<typename Iterator,typename CharType,typename Traits,typename Alloc> operator <(segment<Iterator> const & l,std::basic_string<CharType,Traits,Alloc> const & r)331 bool operator<(segment<Iterator> const &l,std::basic_string<CharType,Traits,Alloc> const &r) 332 { 333 return details::compare_text(l,r) < 0; 334 } 335 /// Compare string and segment 336 template<typename Iterator,typename CharType,typename Traits,typename Alloc> operator <=(segment<Iterator> const & l,std::basic_string<CharType,Traits,Alloc> const & r)337 bool operator<=(segment<Iterator> const &l,std::basic_string<CharType,Traits,Alloc> const &r) 338 { 339 return details::compare_text(l,r) <= 0; 340 } 341 /// Compare string and segment 342 template<typename Iterator,typename CharType,typename Traits,typename Alloc> operator >(segment<Iterator> const & l,std::basic_string<CharType,Traits,Alloc> const & r)343 bool operator>(segment<Iterator> const &l,std::basic_string<CharType,Traits,Alloc> const &r) 344 { 345 return details::compare_text(l,r) > 0; 346 } 347 /// Compare string and segment 348 template<typename Iterator,typename CharType,typename Traits,typename Alloc> operator >=(segment<Iterator> const & l,std::basic_string<CharType,Traits,Alloc> const & r)349 bool operator>=(segment<Iterator> const &l,std::basic_string<CharType,Traits,Alloc> const &r) 350 { 351 return details::compare_text(l,r) >= 0; 352 } 353 354 355 /// Compare C string and segment 356 template<typename CharType,typename IteratorR> operator ==(CharType const * l,segment<IteratorR> const & r)357 bool operator==(CharType const *l,segment<IteratorR> const &r) 358 { 359 return details::compare_string(l,r) == 0; 360 } 361 /// Compare C string and segment 362 template<typename CharType,typename IteratorR> operator !=(CharType const * l,segment<IteratorR> const & r)363 bool operator!=(CharType const *l,segment<IteratorR> const &r) 364 { 365 return details::compare_string(l,r) != 0; 366 } 367 368 /// Compare C string and segment 369 template<typename CharType,typename IteratorR> operator <(CharType const * l,segment<IteratorR> const & r)370 bool operator<(CharType const *l,segment<IteratorR> const &r) 371 { 372 return details::compare_string(l,r) < 0; 373 } 374 /// Compare C string and segment 375 template<typename CharType,typename IteratorR> operator <=(CharType const * l,segment<IteratorR> const & r)376 bool operator<=(CharType const *l,segment<IteratorR> const &r) 377 { 378 return details::compare_string(l,r) <= 0; 379 } 380 /// Compare C string and segment 381 template<typename CharType,typename IteratorR> operator >(CharType const * l,segment<IteratorR> const & r)382 bool operator>(CharType const *l,segment<IteratorR> const &r) 383 { 384 return details::compare_string(l,r) > 0; 385 } 386 /// Compare C string and segment 387 template<typename CharType,typename IteratorR> operator >=(CharType const * l,segment<IteratorR> const & r)388 bool operator>=(CharType const *l,segment<IteratorR> const &r) 389 { 390 return details::compare_string(l,r) >= 0; 391 } 392 393 /// Compare C string and segment 394 template<typename Iterator,typename CharType> operator ==(segment<Iterator> const & l,CharType const * r)395 bool operator==(segment<Iterator> const &l,CharType const *r) 396 { 397 return details::compare_string(l,r) == 0; 398 } 399 /// Compare C string and segment 400 template<typename Iterator,typename CharType> operator !=(segment<Iterator> const & l,CharType const * r)401 bool operator!=(segment<Iterator> const &l,CharType const *r) 402 { 403 return details::compare_string(l,r) != 0; 404 } 405 406 /// Compare C string and segment 407 template<typename Iterator,typename CharType> operator <(segment<Iterator> const & l,CharType const * r)408 bool operator<(segment<Iterator> const &l,CharType const *r) 409 { 410 return details::compare_string(l,r) < 0; 411 } 412 /// Compare C string and segment 413 template<typename Iterator,typename CharType> operator <=(segment<Iterator> const & l,CharType const * r)414 bool operator<=(segment<Iterator> const &l,CharType const *r) 415 { 416 return details::compare_string(l,r) <= 0; 417 } 418 /// Compare C string and segment 419 template<typename Iterator,typename CharType> operator >(segment<Iterator> const & l,CharType const * r)420 bool operator>(segment<Iterator> const &l,CharType const *r) 421 { 422 return details::compare_string(l,r) > 0; 423 } 424 /// Compare C string and segment 425 template<typename Iterator,typename CharType> operator >=(segment<Iterator> const & l,CharType const * r)426 bool operator>=(segment<Iterator> const &l,CharType const *r) 427 { 428 return details::compare_string(l,r) >= 0; 429 } 430 431 432 433 434 435 436 typedef segment<std::string::const_iterator> ssegment; ///< convenience typedef 437 typedef segment<std::wstring::const_iterator> wssegment; ///< convenience typedef 438 #ifdef BOOST_LOCALE_ENABLE_CHAR16_T 439 typedef segment<std::u16string::const_iterator> u16ssegment;///< convenience typedef 440 #endif 441 #ifdef BOOST_LOCALE_ENABLE_CHAR32_T 442 typedef segment<std::u32string::const_iterator> u32ssegment;///< convenience typedef 443 #endif 444 445 typedef segment<char const *> csegment; ///< convenience typedef 446 typedef segment<wchar_t const *> wcsegment; ///< convenience typedef 447 #ifdef BOOST_LOCALE_ENABLE_CHAR16_T 448 typedef segment<char16_t const *> u16csegment; ///< convenience typedef 449 #endif 450 #ifdef BOOST_LOCALE_ENABLE_CHAR32_T 451 typedef segment<char32_t const *> u32csegment; ///< convenience typedef 452 #endif 453 454 455 456 457 458 /// 459 /// Write the segment to the stream character by character 460 /// 461 template<typename CharType,typename TraitsType,typename Iterator> operator <<(std::basic_ostream<CharType,TraitsType> & out,segment<Iterator> const & tok)462 std::basic_ostream<CharType,TraitsType> &operator<<( 463 std::basic_ostream<CharType,TraitsType> &out, 464 segment<Iterator> const &tok) 465 { 466 for(Iterator p=tok.begin(),e=tok.end();p!=e;++p) 467 out << *p; 468 return out; 469 } 470 471 /// @} 472 473 } // boundary 474 } // locale 475 } // boost 476 477 #ifdef BOOST_MSVC 478 #pragma warning(pop) 479 #endif 480 481 #endif 482 483 // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4 484