stringutil.h

Go to the documentation of this file.

// ************************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.14 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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 General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _STRINGUTIL_H_
#define _STRINGUTIL_H_

// ************************************************************************
// included header files
// + standard includes
#include <algorithm>
#include <iterator>
#include <sstream>
#include <string>
#include <limits>

// + local headers

// ************************************************************************
// put version-info into object file
namespace {
}                                       // version info

// ************************************************************************
// namespace extensions
namespace OSB_LIB {
    extern const std::string posixWs;

    void ltrim(
              std::string& s,
        const std::string& d = posixWs
    );

    void rtrim(
              std::string& s,
        const std::string& d = posixWs
    );

    void trim(
              std::string& s,
        const std::string& d = posixWs
    );

    bool endsWith(
        const std::string& str,
        const std::string& what
    );

    std::string lstrip(
        const std::string& from,
        const std::string& what
    );

    std::string rstrip(
        const std::string& from,
        const std::string& what
    );

    void escapeChars(
              std::string& str,
        const char         esc,
              size_t       maxLen
    );

    bool decDigitsOnly(
        const std::string& s
    );

    bool hexDigitsOnly(
        const std::string& s
    );

    template<typename Cont>
    void tokenize(
              Cont&        dest,
        const std::string& src,
        const std::string& del,
              bool         takeEmpty = false
    );

    template<typename Cont>
    void tokenize(
              Cont&        dest,
        const std::string& src
    );

    template<typename Cont>
    void stringTokenize(
              Cont&        dest,
        const std::string& src,
        const std::string& del,
              bool         takeEmpty = true
    );

    template<typename T>
    bool ston(
              T*           dest,
        const std::string& src,
              std::string* reminder = 0
    );

    template<typename T>
    std::string mkStr(const T& src);

    template<typename S = std::string>
    struct StrCmp : public std::binary_function<S, S, int> {
        explicit StrCmp(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
            // empty
        }

        int operator()(
            const S& lhs,
            const S& rhs
        ) const;
    private:
        bool ignoreCase_;
    };                                  // struct StrCmp<S>

    template<typename S = std::string>
    struct LessStr : public std::binary_function<S, S, bool> {
        explicit LessStr(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
            // empty
        }

        bool operator()(
            const S& lhs,
            const S& rhs
        ) const
        {
            return 0 > StrCmp<S>(ignoreCase_)(lhs, rhs);
        }
    private:
        bool ignoreCase_;
    };                                  // struct LessStr<S>

    template<typename S = std::string>
    struct GreaterStr : public std::binary_function<S, S, bool> {
        explicit GreaterStr(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
            // empty
        }

        inline bool operator()(
            const S& lhs,
            const S& rhs
        ) const
        {
            return 0 < StrCmp<S>(ignoreCase_)(lhs, rhs);
        }
    private:
        bool ignoreCase_;
    };                                  // struct GreaterStr<S>

    template<typename T, typename S = std::string>
    struct LessName : public std::binary_function<T, T, bool> {
        explicit LessName(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
            // empty
        }

        inline bool operator()(
            const T& lhs,
            const T& rhs
        ) const
        {
            return LessStr<S>(ignoreCase_)(lhs.name(), rhs.name());
        }
    private:
        bool ignoreCase_;
    };                                  // struct LessName<T, S>

    template<typename T, typename S>
    struct LessName<T*, S> : public std::binary_function<T, T, bool> {
        LessName(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
        }

        inline bool operator()(
            const T* lhs,
            const T* rhs
        ) const
        {
            return LessStr<S>(ignoreCase_)(lhs->name(), rhs->name());
        }
    private:
        bool ignoreCase_;
    };                                  // struct LessName<T*, S>

    template<typename T, typename S = std::string>
    struct GreaterName : public std::binary_function<T, T, bool> {
        GreaterName(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
        }

        inline bool operator()(
            const T& lhs,
            const T& rhs
        ) const
        {
            return GreaterStr<S>(ignoreCase_)(lhs.name(), rhs.name());
        }
    private:
        bool ignoreCase_;
    };                                  // struct GreaterName<T, S>

    template<typename T, typename S>
    struct GreaterName<T*, S> : public std::binary_function<T, T, bool> {
        GreaterName(bool ignoreCase = false)
          : ignoreCase_(ignoreCase)
        {
        }

        inline bool operator()(
            const T* lhs,
            const T* rhs
        ) const
        {
            return GreaterStr<S>(ignoreCase_)(lhs->name(), rhs->name());
        }
    private:
        bool ignoreCase_;
    };                                  // struct GreaterName<T*, S>
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
    template<typename Cont>
    void tokenize(
              Cont&        dest,
        const std::string& src,
        const std::string& del,
              bool         takeEmpty
    )
    {
        using std::string;
        string::size_type len      = src.length();
        string::size_type startPos = 0;
        string::size_type endPos   = string::npos;

        dest.clear();
        while (startPos < len) {
            if (!takeEmpty) {
                // Skip leading delimiters
                startPos = src.find_first_not_of(del, startPos);
                // No non-delimiter found: return
                if (string::npos == startPos) return;
            }

            // Find end of token
            endPos = src.find_first_of(del, startPos);
            // Delimiter found: isolate the token.
            if (string::npos != endPos) {
                dest.push_back(src.substr(startPos, endPos-startPos));
                // Advance in src: examine next character
                startPos = endPos+1;
            }
            // No more delimiters: get the reminder and return.
            else {
                dest.push_back(src.substr(startPos));
                return;
            }
        }
        // We only come here if the last character is a delimiter
        if (takeEmpty && string::npos != endPos) {
            dest.push_back(src.substr(endPos+1));
        }
    }

    template<typename Cont>
    inline void tokenize(
              Cont&        dest,
        const std::string& src
    )
    {
        return tokenize(dest, src, posixWs);
    }

    template<typename Cont>
    void stringTokenize(
              Cont&        dest,
        const std::string& src,
        const std::string& del,
              bool         takeEmpty
    )
    {
        using std::string;

        dest.clear();

        // special case: if the delimiter string is empty we
        // put the whole `src' to the result and return
        if (del.empty()) {
            dest.push_back(src);
            if (!takeEmpty && dest.back().empty()) dest.pop_back();
            return;
        }

        string::size_type srclen   = src.length();
        string::size_type dellen   = del.length();
        string::size_type startPos = 0;

        while (startPos < srclen) {
            // find end of token
            string::size_type endPos = src.find(del, startPos);
            // no more delimiters: exit the while loop
            if (string::npos == endPos) break;

            // delimiter found: isolate the token and advance
            dest.push_back(src.substr(startPos, endPos-startPos));
            if (!takeEmpty && dest.back().empty()) dest.pop_back();
            // advance in src: examine next characters
            startPos = endPos + dellen;
        }
        dest.push_back(src.substr(startPos));
        if (!takeEmpty && dest.back().empty()) dest.pop_back();
    }

    template<typename T>
    bool ston(
              T*           dest,
        const std::string& src,
              std::string* reminder
    )
    {
        typedef std::istream_iterator<char> Iter;

        bool rc = false;
        T t = T();

        std::numeric_limits<T> limits;
        if (limits.is_integer) {
            char* err = 0;

            if (limits.is_signed) t = strtol(src.c_str(), &err, 0);
            else                  t = strtoul(src.c_str(), &err, 0);

            if (0 == err || 0 == *err) {
                rc = true;
            }
            else if (0 != reminder) {
                *reminder = std::string(err);
            }
        }
        else {
            std::istringstream is(src);
            is >> t;
            rc = is && is.eof();

            if (!rc && 0 != reminder) {
                is.clear();
                is >> std::noskipws;
                std::copy(Iter(is), Iter(), std::back_inserter(*reminder));
            }
        }

        if (rc) *dest = t;
        return rc;
    }

    template<typename T>
    std::string mkStr(const T& src)
    {
        std::ostringstream rc;
        rc << src;
        return rc.str();
    }

    // ********************************************************************
    // struct StrCmp<S>
    template<typename S> int StrCmp<S>::operator()(
        const S& lhs,
        const S& rhs
    ) const
    {
        typedef typename S::const_iterator Iter;

        if (!ignoreCase_) return lhs.compare(rhs);

        Iter le = lhs.end();
        Iter re = rhs.end();
        Iter li = lhs.begin();
        Iter ri = rhs.begin();

        for (;li != le && ri != re; ++li, ++ri) {
            char l = toupper(*li);
            char r = toupper(*ri);
            if (l != r) {
                return (l < r) ? -1 : 1;
            }
        }

        if (li == le && ri == re) {
            // we're at the end of both strings: lhs == rhs
            return 0;
        }
        else if (li == le) {
            // we're at the end of lhs, i.e., lhs < rhs
            return -1;
        }
        // we're at the end of rhs, i.e., lhs > rhs
        return 1;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _STRINGUTIL_H_

---