source: GTP/trunk/Lib/Vis/Preprocessing/src/Timer/mstring.h @ 2015

 /* ========================================================================
  * (C) 2000 Vienna University of Technology
  * ========================================================================
  * PROJECT: Urban Viz
  * ========================================================================*/
/** very handy template String class.
  *
  * for char-strings, 'String' is typedef'd for convenience
  * Note: can be used standalone in all std-conforming C++ environments
  *
  * $Header: /usr/local/cvsyare/cvsyamp/include/mstring.h,v 1.1 2002/11/14 15:22:48 wimmer Exp $
  * @author      Michael Wimmer
  * @file                                                                   */
 /* ========================================================================*/

#ifndef NO_PRAGMA_ONCE
#pragma once
#endif

#ifndef MSTRING_H
#define MSTRING_H

// remove completely stupid MSVC warning
#ifdef _MSC_VER
#pragma warning(disable: 4786) // 'identifier' : identifier was truncated to 
                                                           // 'number' characters in the debug information
#endif

// Note: this always uses namespace std. no namespace precautions!
#include <string>
using std::basic_string;

// ---------------------------------------------------------------------------
//  class mbasic_string definition
// ---------------------------------------------------------------------------

// internally used
static const char *MSTRING_WHITESPACE = " \t";


/** Very handy String class.
        Normally, you would use \c mbasic_string<char>, here typedef'd as 'String'.

        Improves upon basic_string by adding:
        - most importantly, a cast to const char *
        - some useful Basic like operations, 
          such as Left, Mid, Right, Trim, Upper, ...
*/
template<class E>
class mbasic_string : public  basic_string<E> {
public:
        // size_type not automatically looked up on sgis
        typedef typename basic_string<E>::size_type size_type;
        
        //-- Constructors

        /// various constructors
        mbasic_string() : basic_string<E>() {}
        
        ///
        mbasic_string(const E *s) : basic_string<E>(s) {}
        
        /// 
        mbasic_string(size_type n, const E c) : basic_string<E>(n, c) {}
        
        /// 
        mbasic_string(const E c) : basic_string<E>(1, c) {}
        
        /// 
        mbasic_string(const mbasic_string<E>& mbs) : basic_string<E>(mbs) {}
        
        /// 
        mbasic_string(const basic_string<E>& bs) : basic_string<E>(bs) {}

        //-- Assignment

        /// various assignment ops
        mbasic_string& operator=(const E c) 
                { basic_string<E>::operator=(c); return *this; }
        
        ///
        mbasic_string& operator=(const E *s) 
                { basic_string<E>::operator=(s); return *this; }
        
        ///
        mbasic_string& operator=(const mbasic_string<E>& rhs) 
                { basic_string<E>::operator=((const basic_string<E>&)rhs); 
                  return *this; }

        /// very useful!
        operator const char*() const { return this->c_str(); }

        //-- special access
        
        /// n characters from position pos (n may be out of range)
        mbasic_string substr(size_type pos = 0, size_type n = npos) const 
        {  basic_string<E> res = basic_string<E>::substr(pos,n); return res; }

        /// leftmost nr characters (no problem if nr too large)
        mbasic_string Left(size_type nr) const { return substr(0,nr); }
        
        /// rightmost nr characters (no problem if nr too large)
        mbasic_string Right(size_type nr) const;
        
        /** substring from position 'from' to position 'to' (no problems 
                if args out of range) */
        mbasic_string Mid(size_type from, size_type to) const
        {       if (from >= size() || from > to) return ""; 
                                                                        else return substr(from,to-from+1); }
        
        //-- padding
        mbasic_string Pad(char padchar, int length) const;

        //-- trimming
        
        /// @name Trimming, converting upper/lower case
        //@{
        /// removes whitespace (space, tab) from the right
        mbasic_string& TrimRightSelf();

        /// removes whitespace (space, tab) from the left
        mbasic_string& TrimLeftSelf();

        /// removes whitespace from both left and right
        mbasic_string& TrimSelf();

        /// returns a 'right-trimmed' copy of string
        mbasic_string TrimRight() const 
                { return mbasic_string<E>(*this).TrimRightSelf(); }
        
        /// returns a 'left-trimmed' copy of string
        mbasic_string TrimLeft() const  
                { return mbasic_string<E>(*this).TrimLeftSelf(); }
        
        /// returns a 'trimmed' copy of string
        mbasic_string Trim() const { return mbasic_string<E>(*this).TrimSelf();}

        //-- upper/lower conversion
        
        /// converts string to uppercase
        mbasic_string& UpperSelf();

        /// converts string to uppercase
        mbasic_string& LowerSelf();

        /// returns an uppercase copy of string
        mbasic_string Upper() const { return mbasic_string<E>(*this).UpperSelf();}
        
        /// returns an uppercase copy of string
        mbasic_string Lower() const { return mbasic_string<E>(*this).LowerSelf();}
        
        //@}

        //-- other stuff
        
        /** in contrast to empty(), also returns true if string is only 
                whitespace (space, tab) */
        bool Empty() const;
};

/// for convenience (that's what you'll use)
typedef mbasic_string<char> String;

// ---------------------------------------------------------------------------
//  class mbasic_string template member implementation
// ---------------------------------------------------------------------------

template<class E>
inline mbasic_string<E> mbasic_string<E>::Right(size_type nr) const 
{
        // take care that pos doesn't become negative
        if(nr > size()) 
        {
                return *this;
        }
        else 
        {
                return substr(size()-nr, nr);
        }
}


// ----- WARNING: the following only useful for E = char or similar!

template<class E>
inline bool mbasic_string<E>::Empty() const 
{
        return (find_first_not_of(MSTRING_WHITESPACE) == npos);
}


template<class E>
inline mbasic_string<E>& mbasic_string<E>::TrimRightSelf() 
{
        if (!empty())
        {
                size_type pos = find_last_not_of(MSTRING_WHITESPACE);
                if(pos == npos) // everything whitespace
                        erase();
                else if(pos != size()-1)        // pos = size()-1 -> no whitespace
                        erase(pos+1);   
        }

        return *this;
}


template<class E>
inline mbasic_string<E>& mbasic_string<E>::TrimLeftSelf() 
{

        if (!empty())
        {
                size_type pos = find_first_not_of(MSTRING_WHITESPACE);
                if(pos == npos) // everything whitespace
                        erase();
                else if(pos != 0) 
                        erase(0 , pos); 
        }

        return *this;
}

template<class E>
inline mbasic_string<E>& mbasic_string<E>::TrimSelf() 
{

        this->TrimRightSelf();

        this->TrimLeftSelf();

        return *this;
}


template<class E>
inline mbasic_string<E> &mbasic_string<E>::UpperSelf() {

        if (!empty())
                for(size_type i = 0; i < length(); i++)
                        at(i) = (E)toupper(at(i));

        return *this;
}

template<class E>
inline mbasic_string<E> &mbasic_string<E>::LowerSelf() {

        if (!empty())
                for(size_type i = 0; i < length(); i++)
                        at(i) = (E)tolower(at(i));

        return *this;
}

template<class E>
inline mbasic_string<E> mbasic_string<E>::Pad(char padchar, int length) const
{
        mbasic_string<E> result(*this);
        while (result.length() < length)
                result += padchar;
        return result;
}

// --------- operator+() definitions

/// string concatentation (defined multiple times to allow good overloads)
template<class E>
inline mbasic_string<E> operator+(const mbasic_string<E>& lhs, 
                                                                  const mbasic_string<E>& rhs) 
{

        return mbasic_string<E>(lhs) += rhs;
}


///
template<class E>
inline mbasic_string<E> operator+(const mbasic_string<E>& lhs, const E *rhs) 
{

        return mbasic_string<E>(lhs) += rhs;
}

///
template<class E>
inline mbasic_string<E> operator+(const mbasic_string<E>& lhs, const E rhs) 
{

        return mbasic_string<E>(lhs) += rhs;
}

///
template<class E>
inline mbasic_string<E> operator+(const E *lhs, const mbasic_string<E>& rhs) 
{

        return mbasic_string<E>(lhs) += rhs;
}

///
template<class E>
inline mbasic_string<E> operator+(const E lhs, const mbasic_string<E>& rhs) 
{

        return mbasic_string<E>(1,lhs) += rhs;
}

#endif // _MSTRING_H