You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
106 lines
3.2 KiB
106 lines
3.2 KiB
// ---------------------------------------------------------------------------- |
|
// Copyright (C) 2002-2006 Marcin Kalicinski |
|
// |
|
// 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) |
|
// |
|
// For more information, see www.boost.org |
|
// ---------------------------------------------------------------------------- |
|
#ifndef BOOST_PROPERTY_TREE_DETAIL_PTREE_UTILS_HPP_INCLUDED |
|
#define BOOST_PROPERTY_TREE_DETAIL_PTREE_UTILS_HPP_INCLUDED |
|
|
|
#include <boost/limits.hpp> |
|
#include <boost/type_traits/integral_constant.hpp> |
|
#include <boost/mpl/has_xxx.hpp> |
|
#include <boost/mpl/and.hpp> |
|
#include <string> |
|
#include <algorithm> |
|
#include <locale> |
|
|
|
namespace boost { namespace property_tree { namespace detail |
|
{ |
|
|
|
template<class T> |
|
struct less_nocase |
|
{ |
|
typedef typename T::value_type Ch; |
|
std::locale m_locale; |
|
inline bool operator()(Ch c1, Ch c2) const |
|
{ |
|
return std::toupper(c1, m_locale) < std::toupper(c2, m_locale); |
|
} |
|
inline bool operator()(const T &t1, const T &t2) const |
|
{ |
|
return std::lexicographical_compare(t1.begin(), t1.end(), |
|
t2.begin(), t2.end(), *this); |
|
} |
|
}; |
|
|
|
template <typename Ch> |
|
struct is_character : public boost::false_type {}; |
|
template <> |
|
struct is_character<char> : public boost::true_type {}; |
|
template <> |
|
struct is_character<wchar_t> : public boost::true_type {}; |
|
|
|
|
|
BOOST_MPL_HAS_XXX_TRAIT_DEF(internal_type) |
|
BOOST_MPL_HAS_XXX_TRAIT_DEF(external_type) |
|
template <typename T> |
|
struct is_translator : public boost::mpl::and_< |
|
has_internal_type<T>, has_external_type<T> > {}; |
|
|
|
|
|
|
|
// Naively convert narrow string to another character type |
|
template<class Ch> |
|
std::basic_string<Ch> widen(const char *text) |
|
{ |
|
std::basic_string<Ch> result; |
|
while (*text) |
|
{ |
|
result += Ch(*text); |
|
++text; |
|
} |
|
return result; |
|
} |
|
|
|
// Naively convert string to narrow character type |
|
template<class Ch> |
|
std::string narrow(const Ch *text) |
|
{ |
|
std::string result; |
|
while (*text) |
|
{ |
|
if (*text < 0 || *text > (std::numeric_limits<char>::max)()) |
|
result += '*'; |
|
else |
|
result += char(*text); |
|
++text; |
|
} |
|
return result; |
|
} |
|
|
|
// Remove trailing and leading spaces |
|
template<class Ch> |
|
std::basic_string<Ch> trim(const std::basic_string<Ch> &s, |
|
const std::locale &loc = std::locale()) |
|
{ |
|
typename std::basic_string<Ch>::const_iterator first = s.begin(); |
|
typename std::basic_string<Ch>::const_iterator end = s.end(); |
|
while (first != end && std::isspace(*first, loc)) |
|
++first; |
|
if (first == end) |
|
return std::basic_string<Ch>(); |
|
typename std::basic_string<Ch>::const_iterator last = end; |
|
do --last; while (std::isspace(*last, loc)); |
|
if (first != s.begin() || last + 1 != end) |
|
return std::basic_string<Ch>(first, last + 1); |
|
else |
|
return s; |
|
} |
|
|
|
} } } |
|
|
|
#endif
|
|
|