| // Boost string_algo library case_conv.hpp header file ---------------------------// |
| |
| // Copyright Pavol Droba 2002-2003. |
| // |
| // Distributed under the Boost Software License, Version 1.0. |
| // (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| |
| // See http://www.boost.org/ for updates, documentation, and revision history. |
| |
| #ifndef BOOST_STRING_CASE_CONV_HPP |
| #define BOOST_STRING_CASE_CONV_HPP |
| |
| #include <boost/algorithm/string/config.hpp> |
| #include <algorithm> |
| #include <locale> |
| #include <boost/iterator/transform_iterator.hpp> |
| |
| #include <boost/range/as_literal.hpp> |
| #include <boost/range/begin.hpp> |
| #include <boost/range/end.hpp> |
| #include <boost/range/value_type.hpp> |
| |
| #include <boost/algorithm/string/detail/case_conv.hpp> |
| |
| /*! \file |
| Defines sequence case-conversion algorithms. |
| Algorithms convert each element in the input sequence to the |
| desired case using provided locales. |
| */ |
| |
| namespace boost { |
| namespace algorithm { |
| |
| // to_lower -----------------------------------------------// |
| |
| //! Convert to lower case |
| /*! |
| Each element of the input sequence is converted to lower |
| case. The result is a copy of the input converted to lower case. |
| It is returned as a sequence or copied to the output iterator. |
| |
| \param Output An output iterator to which the result will be copied |
| \param Input An input range |
| \param Loc A locale used for conversion |
| \return |
| An output iterator pointing just after the last inserted character or |
| a copy of the input |
| |
| \note The second variant of this function provides the strong exception-safety guarantee |
| |
| */ |
| template<typename OutputIteratorT, typename RangeT> |
| inline OutputIteratorT |
| to_lower_copy( |
| OutputIteratorT Output, |
| const RangeT& Input, |
| const std::locale& Loc=std::locale()) |
| { |
| return ::boost::algorithm::detail::transform_range_copy( |
| Output, |
| ::boost::as_literal(Input), |
| ::boost::algorithm::detail::to_lowerF< |
| typename range_value<RangeT>::type >(Loc)); |
| } |
| |
| //! Convert to lower case |
| /*! |
| \overload |
| */ |
| template<typename SequenceT> |
| inline SequenceT to_lower_copy( |
| const SequenceT& Input, |
| const std::locale& Loc=std::locale()) |
| { |
| return ::boost::algorithm::detail::transform_range_copy<SequenceT>( |
| Input, |
| ::boost::algorithm::detail::to_lowerF< |
| typename range_value<SequenceT>::type >(Loc)); |
| } |
| |
| //! Convert to lower case |
| /*! |
| Each element of the input sequence is converted to lower |
| case. The input sequence is modified in-place. |
| |
| \param Input A range |
| \param Loc a locale used for conversion |
| */ |
| template<typename WritableRangeT> |
| inline void to_lower( |
| WritableRangeT& Input, |
| const std::locale& Loc=std::locale()) |
| { |
| ::boost::algorithm::detail::transform_range( |
| ::boost::as_literal(Input), |
| ::boost::algorithm::detail::to_lowerF< |
| typename range_value<WritableRangeT>::type >(Loc)); |
| } |
| |
| // to_upper -----------------------------------------------// |
| |
| //! Convert to upper case |
| /*! |
| Each element of the input sequence is converted to upper |
| case. The result is a copy of the input converted to upper case. |
| It is returned as a sequence or copied to the output iterator |
| |
| \param Output An output iterator to which the result will be copied |
| \param Input An input range |
| \param Loc A locale used for conversion |
| \return |
| An output iterator pointing just after the last inserted character or |
| a copy of the input |
| |
| \note The second variant of this function provides the strong exception-safety guarantee |
| */ |
| template<typename OutputIteratorT, typename RangeT> |
| inline OutputIteratorT |
| to_upper_copy( |
| OutputIteratorT Output, |
| const RangeT& Input, |
| const std::locale& Loc=std::locale()) |
| { |
| return ::boost::algorithm::detail::transform_range_copy( |
| Output, |
| ::boost::as_literal(Input), |
| ::boost::algorithm::detail::to_upperF< |
| typename range_value<RangeT>::type >(Loc)); |
| } |
| |
| //! Convert to upper case |
| /*! |
| \overload |
| */ |
| template<typename SequenceT> |
| inline SequenceT to_upper_copy( |
| const SequenceT& Input, |
| const std::locale& Loc=std::locale()) |
| { |
| return ::boost::algorithm::detail::transform_range_copy<SequenceT>( |
| Input, |
| ::boost::algorithm::detail::to_upperF< |
| typename range_value<SequenceT>::type >(Loc)); |
| } |
| |
| //! Convert to upper case |
| /*! |
| Each element of the input sequence is converted to upper |
| case. The input sequence is modified in-place. |
| |
| \param Input An input range |
| \param Loc a locale used for conversion |
| */ |
| template<typename WritableRangeT> |
| inline void to_upper( |
| WritableRangeT& Input, |
| const std::locale& Loc=std::locale()) |
| { |
| ::boost::algorithm::detail::transform_range( |
| ::boost::as_literal(Input), |
| ::boost::algorithm::detail::to_upperF< |
| typename range_value<WritableRangeT>::type >(Loc)); |
| } |
| |
| } // namespace algorithm |
| |
| // pull names to the boost namespace |
| using algorithm::to_lower; |
| using algorithm::to_lower_copy; |
| using algorithm::to_upper; |
| using algorithm::to_upper_copy; |
| |
| } // namespace boost |
| |
| #endif // BOOST_STRING_CASE_CONV_HPP |