iframe-proxy | Sunbelt Computer Software

History

176 lines (149 loc) · 6.02 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

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

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

case_conv.hpp

Latest commit

History

case_conv.hpp

File metadata and controls