text: //  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,
                 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(
                  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,
                 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(
                  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
  