stringhelper.h
Go to the documentation of this file.
// -*- C++ -*-
// Module: Log4CPLUS
// File: stringhelper.h
// Created: 3/2003
// Author: Tad E. Smith
//
//
// Copyright 2003-2017 Tad E. Smith
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef LOG4CPLUS_HELPERS_STRINGHELPER_HEADER_
#define LOG4CPLUS_HELPERS_STRINGHELPER_HEADER_
#include <log4cplus/config.hxx>
#if defined (LOG4CPLUS_HAVE_PRAGMA_ONCE)
#pragma once
#endif
#include <log4cplus/tstring.h>
#include <algorithm>
#include <limits>
namespace log4cplus {
namespace helpers {
LOG4CPLUS_EXPORT log4cplus::tstring toUpper(const log4cplus::tstring& s);
LOG4CPLUS_EXPORT tchar toUpper(tchar);
LOG4CPLUS_EXPORT log4cplus::tstring toLower(const log4cplus::tstring& s);
LOG4CPLUS_EXPORT tchar toLower(tchar);
template <class StringType, class OutputIter>
inline
void
tokenize(const StringType& s, typename StringType::value_type c,
OutputIter result, bool collapseTokens = true)
{
typedef typename StringType::size_type size_type;
size_type const slen = s.length();
size_type first = 0;
size_type i = 0;
for (i=0; i < slen; ++i)
{
if (s[i] == c)
{
*result = StringType (s, first, i - first);
++result;
if (collapseTokens)
while (i+1 < slen && s[i+1] == c)
++i;
first = i + 1;
}
}
if (first != i)
*result = StringType (s, first, i - first);
else if (! collapseTokens && first == i)
*result = StringType ();
}
template <typename intType, typename stringType, bool isSigned>
struct ConvertIntegerToStringHelper;
template <typename intType, typename charType>
struct ConvertIntegerToStringHelper<intType, charType, true>
{
static inline
void
step1 (charType * & it, intType & value)
{
// The sign of the result of the modulo operator is
// implementation defined. That's why we work with
// positive counterpart instead. Also, in twos
// complement arithmetic the smallest negative number
// does not have positive counterpart; the range is
// asymetric. That's why we handle the case of value
// == min() specially here.
if (LOG4CPLUS_UNLIKELY (
value == (std::numeric_limits<intType>::min) ()))
{
intType const r = value / 10;
intType const a = (-r) * 10;
intType const mod = -(a + value);
value = -r;
*(it - 1)
= static_cast<charType>(LOG4CPLUS_TEXT('0') + mod);
--it;
}
else
value = -value;
}
static
bool
is_negative (intType val)
{
return val < 0;
}
};
template <typename intType, typename charType>
struct ConvertIntegerToStringHelper<intType, charType, false>
{
static inline
void
step1 (charType * &, intType &)
{
// This will never be called for unsigned types.
}
static
bool
is_negative (intType)
{
return false;
}
};
template <class stringType, class intType>
inline
void
convertIntegerToString (stringType & str, intType value)
{
typedef std::numeric_limits<intType> intTypeLimits;
typedef typename stringType::value_type charType;
typedef ConvertIntegerToStringHelper<intType, charType,
intTypeLimits::is_signed> HelperType;
charType buffer[intTypeLimits::digits10 + 2];
const std::size_t buffer_size
= sizeof (buffer) / sizeof (charType);
charType * it = &buffer[buffer_size];
charType const * const buf_end = &buffer[buffer_size];
if (LOG4CPLUS_UNLIKELY (value == 0))
{
--it;
*it = LOG4CPLUS_TEXT('0');
}
else
{
bool const negative = HelperType::is_negative (value);
if (negative)
HelperType::step1 (it, value);
for (; value != 0; --it)
{
intType mod = value % 10;
value = value / 10;
*(it - 1) = static_cast<charType>(LOG4CPLUS_TEXT('0')
+ mod);
}
if (negative)
{
--it;
*it = LOG4CPLUS_TEXT('-');
}
}
str.assign (static_cast<charType const *>(it), buf_end);
}
template<class intType>
inline
tstring
convertIntegerToString (intType value)
{
tstring result;
convertIntegerToString (result, value);
return result;
}
template<class intType>
inline
std::string
convertIntegerToNarrowString (intType value)
{
std::string result;
convertIntegerToString (result, value);
return result;
}
template <typename Iterator, typename Separator>
inline
void
join_worker (tstring & result, Iterator & start, Iterator & last,
Separator const & sep)
{
if (start != last)
result = *start++;
for (; start != last; ++start)
{
result += sep;
result += *start;
}
}
template <typename Iterator>
inline
void
join (tstring & result, Iterator start, Iterator last,
tstring const & sep)
{
join_worker (result, start, last, sep);
}
template <typename Iterator>
inline
void
join (tstring & result, Iterator start, Iterator last,
tstring::value_type sep)
{
join_worker (result, start, last, sep);
}
} // namespace helpers
} // namespace log4cplus
#endif // LOG4CPLUS_HELPERS_STRINGHELPER_HEADER_
LOG4CPLUS_TEXT
#define LOG4CPLUS_TEXT(STRING)
Definition clogger.h:72
config.hxx
LOG4CPLUS_UNLIKELY
#define LOG4CPLUS_UNLIKELY(cond)
Definition config.hxx:141
log4cplus::helpers
Definition appender.h:50
log4cplus::helpers::toUpper
LOG4CPLUS_EXPORT log4cplus::tstring toUpper(const log4cplus::tstring &s)
Returns s in upper case.
log4cplus::helpers::join_worker
void join_worker(tstring &result, Iterator &start, Iterator &last, Separator const &sep)
Join a list of items into a string.
Definition stringhelper.h:233
log4cplus::helpers::join
void join(tstring &result, Iterator start, Iterator last, tstring const &sep)
Join a list of items into a string.
Definition stringhelper.h:250
log4cplus::helpers::convertIntegerToString
void convertIntegerToString(stringType &str, intType value)
Definition stringhelper.h:163
log4cplus::helpers::tokenize
void tokenize(const StringType &s, typename StringType::value_type c, OutputIter result, bool collapseTokens=true)
Tokenize s using c as the delimiter and put the resulting tokens in _result.
Definition stringhelper.h:72
log4cplus::helpers::convertIntegerToNarrowString
std::string convertIntegerToNarrowString(intType value)
Definition stringhelper.h:221
log4cplus::helpers::toLower
LOG4CPLUS_EXPORT log4cplus::tstring toLower(const log4cplus::tstring &s)
Returns s in lower case.
log4cplus
Definition appender.h:46
log4cplus::tstring
std::basic_string< tchar > tstring
Definition tstring.h:39
log4cplus::tchar
char tchar
Definition tchar.h:56
log4cplus::helpers::ConvertIntegerToStringHelper< intType, charType, false >::step1
static void step1(charType *&, intType &)
Definition stringhelper.h:146
log4cplus::helpers::ConvertIntegerToStringHelper< intType, charType, false >::is_negative
static bool is_negative(intType)
Definition stringhelper.h:153
log4cplus::helpers::ConvertIntegerToStringHelper< intType, charType, true >::is_negative
static bool is_negative(intType val)
Definition stringhelper.h:134
log4cplus::helpers::ConvertIntegerToStringHelper< intType, charType, true >::step1
static void step1(charType *&it, intType &value)
Definition stringhelper.h:107
log4cplus::helpers::ConvertIntegerToStringHelper
Definition stringhelper.h:99
tstring.h
LOG4CPLUS_EXPORT
#define LOG4CPLUS_EXPORT
Definition win32.h:141