MboStrHelper.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      MboStrHelper.h
 *
 * Requires:  
 * - Mbo.h
 * - MboTString.h
 */
/* ------------------------------------------------------------------------ */

#ifndef _MBOSTRHELPER_H_
#define _MBOSTRHELPER_H_

#include "Mbo.h"
#include "MboTString.h"
#include <string>
#include <sstream>
#include <functional>
#include <assert.h>

#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable: 4251) // disable warning C4251: '...' : class '...' needs to have dll-interface to be used by clients of class '...'
# pragma warning(disable: 4275) // non dll-interface class '...' used as base for dll-interface class '...'
#endif

#if defined(_MSC_VER) && (_MSC_VER < 1300 || !defined(snprintf))
# define snprintf _snprintf
#endif

namespace mbo {

template<class _E>
inline _E* StrUpper(_IN _E *str)
{
#ifdef _STLPORT_VERSION
    MBO_MT_LOCAL_OR_STATIC const std::locale loc = std::locale::empty();
#else
    MBO_MT_LOCAL_OR_STATIC const std::ctype<_E>& facet = get_facet<_E>();
#endif

    for (_E *pos = str; *pos; ++pos)
    {
#ifdef _STLPORT_VERSION
        *pos = std::toupper(*pos, loc);
#else
        *pos = facet.toupper(*pos);
#endif
    }
    return str;
}

template<>
inline char* StrUpper(_IN char *str)
{
    return _strupr(str);
}

template<>
inline unsigned char* StrUpper(_IN unsigned char *str)
{
    return _mbsupr(str);
}

template<>
inline wchar_t* StrUpper(_IN wchar_t *str)
{
    return _wcsupr(str);
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> & StrUpper(_IN std::basic_string<_E, _Tr, _A> & str)
{
    StrUpper(const_cast<_E*>(str.c_str()));
    return str;
}

template<class _E>
inline _E* StrLower(_E *str)
{
#ifdef _STLPORT_VERSION
    MBO_MT_LOCAL_OR_STATIC const std::locale loc = std::locale::empty();
#else
    MBO_MT_LOCAL_OR_STATIC const std::ctype<_E>& facet = get_facet<_E>();
#endif

    for (_E *pos = str; *pos; ++pos)
    {
#ifdef _STLPORT_VERSION
        *pos = std::tolower(*pos, loc);
#else
        *pos = facet.tolower(*pos);
#endif
    }
    return str;
}

template<>
inline char* StrLower(_IN char *str)
{
    return _strlwr(str);
}

template<>
inline unsigned char* StrLower(_IN unsigned char *str)
{
    return _mbslwr(str);
}

template<>
inline wchar_t* StrLower(_IN wchar_t *str)
{
    return _wcslwr(str);
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> & StrLower(_IN std::basic_string<_E, _Tr, _A> & str)
{
    StrLower(const_cast<_E*>(str.c_str()));
    return str;
}

template<class _E>
inline int StrCompareIC(_IN const _E *lhs, _IN const _E *rhs)
{
#ifdef _STLPORT_VERSION
    MBO_MT_LOCAL_OR_STATIC const std::locale loc = std::locale::empty();
#else
    MBO_MT_LOCAL_OR_STATIC const std::ctype<_E>& facet = get_facet<_E>();
#endif

    for (; *lhs && *rhs; ++lhs, ++rhs)
    {
#ifdef _STLPORT_VERSION
        int i = std::tolower(*lhs, loc)
              - std::tolower(*rhs, loc);
#else
        int i = facet.tolower(*lhs) - facet.tolower(*rhs);
#endif

        if (i)
        {
            return i;
        }
    }

    return static_cast<int>(*lhs != 0) - static_cast<int>(*rhs != 0);
}

template<>
inline int StrCompareIC(_IN const char *lhs, _IN const char *rhs)
{
    return _stricmp(lhs, rhs);
}

template<>
inline int StrCompareIC(_IN const unsigned char *lhs, _IN const unsigned char *rhs)
{
    return _mbsicmp(lhs, rhs);
}

template<>
inline int StrCompareIC(_IN const wchar_t *lhs, _IN const wchar_t *rhs)
{
    return _wcsicmp(lhs, rhs);
}

template<class _E, class _Tr, class _A>
inline int StrCompareIC(_IN const std::basic_string<_E, _Tr, _A>& lhs, _IN const _E *rhs)
{
    return StrCompareIC(lhs.c_str(), rhs);
}

template<class _E, class _Tr, class _A>
inline int StrCompareIC(_IN const _E *lhs, _IN const std::basic_string<_E, _Tr, _A>& rhs)
{
    return StrCompareIC(lhs, rhs.c_str());
}

template<class _E, class _Tr, class _A>
inline int StrCompareIC(
        _IN const std::basic_string<_E, _Tr, _A>& lhs, 
        _IN const std::basic_string<_E, _Tr, _A>& rhs
    )
{
    return StrCompareIC(lhs.c_str(), rhs.c_str());
}

template<class _Ty>
struct less_ic: std::less<_Ty>
{
    bool operator() (const _Ty& lhs, const _Ty& rhs) const
    {
        return StrCompareIC(lhs, rhs) < 0;
    }
};

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> & StrTrimLeft(_IN std::basic_string<_E, _Tr, _A> & str)
{
    MBO_MT_LOCAL_OR_STATIC const std::basic_string<_E, _Tr, _A> strTrimChars(StrCreate<_E, _Tr, _A>(" \r\n\t"));

    return str.erase(0, str.find_first_not_of(strTrimChars));
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> & StrTrimRight(_IN std::basic_string<_E, _Tr, _A> & str)
{
    MBO_MT_LOCAL_OR_STATIC const std::basic_string<_E, _Tr, _A> strTrimChars(StrCreate<_E, _Tr, _A>(" \r\n\t"));

    std::basic_string<_E, _Tr, _A>::size_type pos = str.find_last_not_of(strTrimChars);
    
    if (pos != std::basic_string<_E, _Tr, _A>::npos)
    {
        str.resize(pos + 1);
        return str;
    }
    else
    {
        str.resize(0);
        return str;
    }
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> & StrTrim(_IN std::basic_string<_E, _Tr, _A> & str)
{
    return StrTrimLeft(StrTrimRight(str));
}

template<class _E, typename _ValType>
inline std::basic_string<_E> StrFrom(_IN const _ValType & val)
{
    std::basic_stringbuf<_E> buf;
    std::basic_ostream<_E> out(&buf);
    out << val;
    return buf.str();
}

template<>
inline std::basic_string<char> StrFrom(_IN const int & val)
{
    char buf[32];

    snprintf(buf, sizeof(buf), "%d", val);
    return std::basic_string<char>(buf);
}

template<>
inline std::basic_string<char> StrFrom(_IN const long & val)
{
    char buf[32];

    snprintf(buf, sizeof(buf), "%ld", val);
    return std::basic_string<char>(buf);
}

template<>
inline std::basic_string<char> StrFrom(_IN const bool & val)
{
    return val ? std::basic_string<char>("1") : std::basic_string<char>("0");
}

template<typename _ValType, class _E, class _Tr, class _A>
inline _ValType StrTo(_IN const std::basic_string<_E, _Tr, _A> & str)
{
    using std::basic_stringbuf;
    using std::basic_istream;
    basic_stringbuf<_E> buf(str, std::ios_base::in | std::ios_base::out);
    basic_istream<_E> in(&buf);
    _ValType val;
    in >> val;
    return val;
}

template<class _E, class _Tr, class _A>
inline int StrToInt(_IN const std::basic_string<_E, _Tr, _A> & str)
{
    return StrTo<int, _E, _Tr, _A>(str);
}

template<class _E, class _Tr, class _A>
inline long StrToLong(_IN const std::basic_string<_E, _Tr, _A> & str)
{
    return StrTo<long, _E, _Tr, _A>(str.c_str());
}

template<class _E, class _Tr, class _A>
inline float StrToFloat(_IN const std::basic_string<_E, _Tr, _A> & str)
{
    return StrTo<float, _E, _Tr, _A>(str.c_str());
}

template<>
inline float StrToFloat(_IN const std::basic_string<char> & str)
{
    float val;
    sscanf(str.c_str(), "%f", &val);
    return val;
}

template<class _E>
inline std::basic_string<_E> StrFromDouble(
        _IN double   val,
        _IN int      iWidth     = -16, 
        _IN int      iPrecision = 10
    )
{
    typedef std::basic_string<_E>  string_type;
    typedef string_type::size_type size_type;

    const size_type npos = string_type::npos;

    char szTemp[128];

    assert(abs(iWidth) < sizeof(szTemp));
    assert(iPrecision >= 0);

    if (iWidth < 0)
    {
        snprintf(szTemp, sizeof(szTemp)-1, "%0g", val);
        std::basic_string<_E> str(szTemp);
        StrTrim(str);
        size_type pos = str.find('.');
        size_type nok = str.find('e') & str.find('E') & (pos>=0 ? str.find('-', pos) : -1) & str.find('+', pos) & str.find(' ', pos);
        if (nok == npos && iPrecision)
        {
            if (pos == npos)
            {
                pos = str.length();
                str += '.';
            }
            int len = static_cast<int>(str.length() - pos - 1); // length of fractional part
            // need to add '0's?
            while(len < iPrecision)
            {
                str += '0';
                len++;
            }
            // need to drop digits?
            if (len > iPrecision)
            {
                str.resize(len--);
            }
            // remove front space if unwanted
            len = - static_cast<int>(str.length());
            while(str[0] == ' ' && len < iWidth)
            {
                str.erase(0, 1);
                len++;
            }
        }
        return str;
    }
    else
    {
        snprintf(szTemp, sizeof(szTemp)-1, "%*.*g", iWidth, iPrecision, val);
        return std::basic_string<_E>(szTemp);
    }
}

template<class _E>
inline std::basic_string<_E> StrFromFloat(
        _IN double   val,
        _IN int      iWidth     = -10, 
        _IN int      iPrecision = 6
    )
{
    return StrFromDouble<_E>(static_cast<double>(val), iWidth, iPrecision);
}

template<class _E>
inline std::basic_string<_E> StrFromBool(_IN bool val)
{
    return StrCreate<_E, std::char_traits<_E>, std::allocator<_E> >(val ? "true" : "false");
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> StrUCFirst(_IN const std::basic_string<_E, _Tr, _A> & str)
{
#ifdef _STLPORT_VERSION
    MBO_MT_LOCAL_OR_STATIC const std::locale loc = std::locale::empty();
#else
    MBO_MT_LOCAL_OR_STATIC const std::ctype<_E>& facet = get_facet<_E>();
#endif
    
    typedef std::basic_string<_E, _Tr, _A> _Str;

    _Str res(str);
    int  bWasAlnum = false;

    for(_Str::iterator it = res.begin(); it != res.end(); ++it)
    {
#ifdef _STLPORT_VERSION
        int bIsAlnum = std::isalnum(*it, loc);
#else
        int bIsAlnum = facet.is(std::ctype<_E>::alnum, *it); /* [a-zA-Z0-9_] */
#endif

        if (!bWasAlnum && bIsAlnum)
        {
#ifdef _STLPORT_VERSION
            *it = std::toupper(*it, loc);
#else
            *it = facet.toupper(*it);
#endif
        } 
        else 
        {
#ifdef _STLPORT_VERSION
            int bIsUpper = std::isupper(*it, loc);;
#else
            int bIsUpper = facet.is(std::ctype<_E>::upper, *it);
#endif
            if (bIsUpper)
            {
#ifdef _STLPORT_VERSION
                *it = std::tolower(*it, loc);
#else
                *it = facet.tolower(*it);
#endif
            }
        }
        bWasAlnum = bIsAlnum;
    }
    return res;
}

template<class _E, class _Tr, class _A>
inline bool StrStartsWith(
        _IN const std::basic_string<_E, _Tr, _A> & str,
        _IN const std::basic_string<_E, _Tr, _A> & strPrefix,
        _IN bool                                   bCaseSensitive = true
    )
{
    std::basic_string<_E, _Tr, _A>::size_type preflen = strPrefix.length();

    if (preflen <= str.length())
    {
        if (!bCaseSensitive)
        {
            return !str.compare(0, preflen, strPrefix);
        }
        else
        {
            std::basic_string<_E, _Tr, _A> strIn(str.substr(0, preflen));
            std::basic_string<_E, _Tr, _A> strPr(strPrefix);
            return !StrLower(strIn).compare(StrLower(strPr));
        }
    }
    else
    {
        return !preflen;
    }
}

template<class _E, class _Tr, class _A>
inline bool StrEndsWith(
        _IN const std::basic_string<_E, _Tr, _A> & str,
        _IN const std::basic_string<_E, _Tr, _A> & strPostfix,
        _IN bool                                   bCaseSensitive = true
    )
{
    std::basic_string<_E, _Tr, _A>::size_type postlen = strPostfix.length();

    if (postlen <= str.length())
    {
        if (!bCaseSensitive)
        {
            return !str.compare(str.length() - postlen, postlen, strPostfix);
        }
        else
        {
            std::basic_string<_E, _Tr, _A> strIn(str.substr(str.length() - postlen));
            std::basic_string<_E, _Tr, _A> strPr(strPostfix);
            return !StrLower(strIn).compare(StrLower(strPr));
        }
    }
    else
    {
        return !postlen;
    }
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> LeftString(
        _IN const std::basic_string<_E, _Tr, _A> &      str,
        _IN typename _A::size_type                      nLength,
        _IN const std::basic_string<_E, _Tr, _A> *      strMore   = NULL,
        _IN const std::basic_string<_E, _Tr, _A> *      strAppend = NULL
    )
{
    if (str.length() > nLength && strMore && strMore->length())
    {
        if (strMore->length() >= nLength)
        {
            return strMore->substr(0, nLength);
        }
        else
        {
            return str.substr(0, nLength - strMore->length()) + *strMore;
        }
    }
    else
    {
        if (strAppend && strAppend->length())
        {
            /* direct return is impossible when using Rational tools */
            //return (str + *strAppend).substr(0, nLength);
            std::basic_string<_E, _Tr, _A>  strConcat = str + *strAppend;
            std::basic_string<_E, _Tr, _A>  strResult = strConcat.substr(0, nLength);
            return strResult;
        }
        else
        {
            /* direct return is impossible when using Rational tools */
            //return str.substr(0, nLength);
            std::basic_string<_E, _Tr, _A>  strResult = str.substr(0, nLength);
            return strResult;
        }
    }
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> LeftString(
        _IN const std::basic_string<_E, _Tr, _A> &      str,
        _IN typename _A::size_type                      nLength,
        _IN const std::basic_string<_E, _Tr, _A> &      strMore
    )
{
    return LeftString<_E, _Tr, _A>(str, nLength, &strMore, NULL);
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> LeftString(
        _IN const std::basic_string<_E, _Tr, _A> &      str,
        _IN typename _A::size_type                      nLength,
        _IN const std::basic_string<_E, _Tr, _A> &      strMore,
        _IN const std::basic_string<_E, _Tr, _A> &      strAppend
    )
{
    return LeftString<_E, _Tr, _A>(str, nLength, &strMore, &strAppend);
}

template<class _E, class _Tr, class _A>
inline bool StrSplit(
        _IN  const std::basic_string<_E, _Tr, _A> &   strValue,  
        _IN  const std::basic_string<_E, _Tr, _A> &   strSplit,  
        _OUT std::basic_string<_E, _Tr, _A> &         strLeft,
        _OUT std::basic_string<_E, _Tr, _A> &         strRight,
        _IN  bool                                     bTrim = false 
    )
{
    bool bFoundEq;

    if (strSplit.empty())
    {
        strLeft  = strValue;
        strRight = "";
        bFoundEq = false;
    }
    else
    {
        std::basic_string<_E, _Tr, _A>::size_type p = strValue.find(strSplit);
    
        if (p == std::basic_string<_E, _Tr, _A>::npos)
        {
            strLeft  = strValue;
            strRight = "";
            bFoundEq = false;
        }
        else if (!p)
        {
            strLeft  = "";
            strRight = strValue.substr(strSplit.size());
            bFoundEq = true;
        }
        else
        {
            strRight = strValue.substr(p + strSplit.size());
            strLeft  = strValue.substr(0, p);
            bFoundEq = true;
        }
    }
    if (bTrim)
    {
        StrTrim(strLeft);
        StrTrim(strRight);
    }
    return bFoundEq;
}

template<class _E, class _Tr, class _A>
inline size_t StrOccurences(
        _IN std::basic_string<_E, _Tr, _A> & str,
        _IN std::basic_string<_E, _Tr, _A> & strFind
     )
{
    size_t nOccurences = 0;
    std::basic_string<_E, _Tr, _A>::size_type pos = 0;

    while ((pos = str.find(strFind, pos)) != std::basic_string<_E, _Tr, _A>::npos)
    {
        nOccurences++;
        pos++;
    }
    return nOccurences;
}

template<class _E, class _Tr, class _A>
std::basic_string<_E, _Tr, _A> & StrReplace(
        _IN _OUT  std::basic_string<_E, _Tr, _A> & str, 
        _IN const std::basic_string<_E, _Tr, _A> & strOld,
        _IN const std::basic_string<_E, _Tr, _A> & strNew
    )
{
    std::basic_string<_E, _Tr, _A>::size_type pos = 0;

    while ((pos = str.find_first_of(strOld, pos)) != std::basic_string<_E, _Tr, _A>::npos)
    {
        str.erase(pos, strOld.length());
        str.insert(pos, strNew);
        pos += strNew.length();
    }

    return str;
}

template<class _E, class _Tr, class _A>
inline std::basic_string<_E, _Tr, _A> & StrReplace(
        _IN _OUT  std::basic_string<_E, _Tr, _A> & str, 
        _IN const _E *                             strOld,
        _IN const _E *                             strNew
    )
{
    return StrReplace(str, std::basic_string<_E, _Tr, _A>(strOld), std::basic_string<_E, _Tr, _A>(strNew));
}

template<class _E, class _Tr, class _A>
std::basic_string<_E, _Tr, _A> StrEncodeXML(
        _IN const std::basic_string<_E, _Tr, _A> & _str
    )
{
    std::basic_string<_E, _Tr, _A> str(_str);
    mbo::StrReplace(str, "&", "&amp;");
    mbo::StrReplace(str, "<", "&lt;");
    mbo::StrReplace(str, ">", "&gt;");
    mbo::StrReplace(str, "'", "&apos;");
    mbo::StrReplace(str, "\"", "&quot;");
    return str;
}

inline std::string & StrParseEnvVars(
        _IN std::string & str,
        _IN char          cOpen,
        _IN char          cClose
    )
{
    for(;;)
    {
        std::string::size_type n1 = str.find(cOpen);
        std::string::size_type n2 = (n1 != std::string::npos) ? str.find(cClose, n1) : std::string::npos;

        if (n2 != std::string::npos)
        {
            std::string env(str.substr(n1 + 1, n2 - n1 - 1));
            return str.replace(n1, n2 - n1 + 1, getenv(env.c_str()));
        }
        else
        {
            return str;
        }
    }
}

}; // namespace mbo

#if defined(_MSC_VER)
# pragma warning(pop)
#endif

#endif //_MBOSTRHELPER_H_

---