1 // Boost string_algo library case_conv.hpp header file ---------------------------// 2 3 // Copyright Pavol Droba 2002-2003. 4 // 5 // Distributed under the Boost Software License, Version 1.0. 6 // (See accompanying file LICENSE_1_0.txt or copy at 7 // http://www.boost.org/LICENSE_1_0.txt) 8 9 // See http://www.boost.org/ for updates, documentation, and revision history. 10 11 #ifndef BOOST_STRING_CASE_CONV_HPP 12 #define BOOST_STRING_CASE_CONV_HPP 13 14 #include <boost/algorithm/string/config.hpp> 15 #include <algorithm> 16 #include <locale> 17 #include <boost/iterator/transform_iterator.hpp> 18 19 #include <boost/range/as_literal.hpp> 20 #include <boost/range/begin.hpp> 21 #include <boost/range/end.hpp> 22 #include <boost/range/value_type.hpp> 23 24 #include <boost/algorithm/string/detail/case_conv.hpp> 25 26 /*! \file 27 Defines sequence case-conversion algorithms. 28 Algorithms convert each element in the input sequence to the 29 desired case using provided locales. 30 */ 31 32 namespace boost { 33 namespace algorithm { 34 35 // to_lower -----------------------------------------------// 36 37 //! Convert to lower case 38 /*! 39 Each element of the input sequence is converted to lower 40 case. The result is a copy of the input converted to lower case. 41 It is returned as a sequence or copied to the output iterator. 42 43 \param Output An output iterator to which the result will be copied 44 \param Input An input range 45 \param Loc A locale used for conversion 46 \return 47 An output iterator pointing just after the last inserted character or 48 a copy of the input 49 50 \note The second variant of this function provides the strong exception-safety guarantee 51 52 */ 53 template<typename OutputIteratorT, typename RangeT> 54 inline OutputIteratorT to_lower_copy(OutputIteratorT Output,const RangeT & Input,const std::locale & Loc=std::locale ())55 to_lower_copy( 56 OutputIteratorT Output, 57 const RangeT& Input, 58 const std::locale& Loc=std::locale()) 59 { 60 return ::boost::algorithm::detail::transform_range_copy( 61 Output, 62 ::boost::as_literal(Input), 63 ::boost::algorithm::detail::to_lowerF< 64 typename range_value<RangeT>::type >(Loc)); 65 } 66 67 //! Convert to lower case 68 /*! 69 \overload 70 */ 71 template<typename SequenceT> to_lower_copy(const SequenceT & Input,const std::locale & Loc=std::locale ())72 inline SequenceT to_lower_copy( 73 const SequenceT& Input, 74 const std::locale& Loc=std::locale()) 75 { 76 return ::boost::algorithm::detail::transform_range_copy<SequenceT>( 77 Input, 78 ::boost::algorithm::detail::to_lowerF< 79 typename range_value<SequenceT>::type >(Loc)); 80 } 81 82 //! Convert to lower case 83 /*! 84 Each element of the input sequence is converted to lower 85 case. The input sequence is modified in-place. 86 87 \param Input A range 88 \param Loc a locale used for conversion 89 */ 90 template<typename WritableRangeT> to_lower(WritableRangeT & Input,const std::locale & Loc=std::locale ())91 inline void to_lower( 92 WritableRangeT& Input, 93 const std::locale& Loc=std::locale()) 94 { 95 ::boost::algorithm::detail::transform_range( 96 ::boost::as_literal(Input), 97 ::boost::algorithm::detail::to_lowerF< 98 typename range_value<WritableRangeT>::type >(Loc)); 99 } 100 101 // to_upper -----------------------------------------------// 102 103 //! Convert to upper case 104 /*! 105 Each element of the input sequence is converted to upper 106 case. The result is a copy of the input converted to upper case. 107 It is returned as a sequence or copied to the output iterator 108 109 \param Output An output iterator to which the result will be copied 110 \param Input An input range 111 \param Loc A locale used for conversion 112 \return 113 An output iterator pointing just after the last inserted character or 114 a copy of the input 115 116 \note The second variant of this function provides the strong exception-safety guarantee 117 */ 118 template<typename OutputIteratorT, typename RangeT> 119 inline OutputIteratorT to_upper_copy(OutputIteratorT Output,const RangeT & Input,const std::locale & Loc=std::locale ())120 to_upper_copy( 121 OutputIteratorT Output, 122 const RangeT& Input, 123 const std::locale& Loc=std::locale()) 124 { 125 return ::boost::algorithm::detail::transform_range_copy( 126 Output, 127 ::boost::as_literal(Input), 128 ::boost::algorithm::detail::to_upperF< 129 typename range_value<RangeT>::type >(Loc)); 130 } 131 132 //! Convert to upper case 133 /*! 134 \overload 135 */ 136 template<typename SequenceT> to_upper_copy(const SequenceT & Input,const std::locale & Loc=std::locale ())137 inline SequenceT to_upper_copy( 138 const SequenceT& Input, 139 const std::locale& Loc=std::locale()) 140 { 141 return ::boost::algorithm::detail::transform_range_copy<SequenceT>( 142 Input, 143 ::boost::algorithm::detail::to_upperF< 144 typename range_value<SequenceT>::type >(Loc)); 145 } 146 147 //! Convert to upper case 148 /*! 149 Each element of the input sequence is converted to upper 150 case. The input sequence is modified in-place. 151 152 \param Input An input range 153 \param Loc a locale used for conversion 154 */ 155 template<typename WritableRangeT> to_upper(WritableRangeT & Input,const std::locale & Loc=std::locale ())156 inline void to_upper( 157 WritableRangeT& Input, 158 const std::locale& Loc=std::locale()) 159 { 160 ::boost::algorithm::detail::transform_range( 161 ::boost::as_literal(Input), 162 ::boost::algorithm::detail::to_upperF< 163 typename range_value<WritableRangeT>::type >(Loc)); 164 } 165 166 } // namespace algorithm 167 168 // pull names to the boost namespace 169 using algorithm::to_lower; 170 using algorithm::to_lower_copy; 171 using algorithm::to_upper; 172 using algorithm::to_upper_copy; 173 174 } // namespace boost 175 176 #endif // BOOST_STRING_CASE_CONV_HPP 177