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 |

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> |

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> |

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 |

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> |

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> |

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 |