/home/rto/work/hstring/include/hstring.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2008, Rasmus Toftdahl Olesen <halfdan@halfdans.net>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 * 
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer
 *      in the documentation and/or other materials provided with the
 *      distribution.
 *
 *    * Neither the name of halfdans.net nor the names of its
 *      contributors may be used to endorse or promote products
 *      derived from this software without specific prior written
 *      permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef NET_HALFDANS_HSTRING_HPP
#define NET_HALFDANS_HSTRING_HPP

#include <string>
#include <sstream>
#include <vector>
#include <iostream>

namespace net
{
    namespace halfdans
    {
        class String;
        
        class StringList : public std::vector<String>
        {
        public:
            String & operator[] ( int _index )
            {
                if ( _index < 0 )
                {
                    _index = size() + _index;
                }
                return std::vector<String>::operator[] ( _index );
            }
            
            const String & operator[] ( int _index ) const
            {
                if ( _index < 0 )
                {
                    _index = size() + _index;
                }
                return std::vector<String>::operator[] ( _index );
            }
            
            void purgeEmpty ();
            void stripAndPurgeEmpty ( const std::string & _letters = " \t\r\n" );
        };

        class String : public std::string
        {
        public:
            //static const char* WHITESPACE = " \t\r\n";
            
            template<typename T>
            String ( T _value )
            {
                std::stringstream ss;
                ss << _value;
                *this = ss.str();
            }
            
            explicit String ( size_type _size, value_type _character )
                : std::string ( _size, _character )
            {
            }
            
            explicit String ( const std::string & _value = "" ) : std::string(_value) {}
            
            template<typename T1>
            explicit String ( const String & format, T1 arg1 )
            {
                *this = format.replace("%1", String(arg1));
            }
            
            template<typename T1, typename T2>
            explicit String ( const String & format, T1 arg1, T2 arg2 )
            {
                *this = format.replace("%1", String(arg1)).replace("%2", String(arg2));
            }

            template<typename T1, typename T2, typename T3>
            explicit String ( const String & format, T1 arg1, T2 arg2, T3 arg3 )
            {
                *this = format.replace("%1", String(arg1)).replace("%2", String(arg2))
                    .replace("%3", String(arg3));
            }

            template<typename T1, typename T2, typename T3, typename T4>
            explicit String ( const String & format, T1 arg1, T2 arg2, T3 arg3, T4 arg4 )
            {
                *this = format.replace("%1", String(arg1)).replace("%2", String(arg2))
                    .replace("%3", String(arg3)).replace("%4", String(arg4));
            }
        
            template<typename T1, typename T2, typename T3, typename T4, typename T5>
            explicit String ( const String & format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5 )
            {
                *this = format.replace("%1", String(arg1)).replace("%2", String(arg2))
                    .replace("%3", String(arg3)).replace("%4", String(arg4)).replace("%5", String(arg5));
            }
            
            template<typename T>
            void operator= ( T _value )
            {
                *this = String(_value);
            }
            
            String replace ( const std::string &a, const std::string &b ) const
            {
                String ret;
                std::string::size_type i = 0;
                std::string::size_type j = this->find(a);
                while ( j != std::string::npos )
                {
                    ret += this->substr(i, j - i);
                    ret += b;
                    i = j + a.size();
                    j = find(a, i);
                }
                if ( i != this->size() ) {
                    ret += this->substr(i, this->size() - i);
                }
                return ret;
            }

            String rstrip ( const std::string & _letters = " \t\n\r" ) const
            {
                std::string::size_type end = this->find_last_not_of(_letters);
                return String( this->substr(0, end + 1) );
            }
        
            String lstrip ( const std::string & _letters = " \t\n\r" ) const
            {
                std::string::size_type start = this->find_first_not_of(_letters);
                return String( this->substr(start, this->size() - start) );
            }

            String strip ( const std::string & _letters = " \t\n\r" ) const
            {
                std::string::size_type start = this->find_first_not_of(_letters);
                std::string::size_type end = this->find_last_not_of(_letters);
                if ( start == end )
                {
                    if ( start == std::string::npos )
                    {
                        return String();
                    }
                    else
                    {
                        return *this;
                    }
                }
                else
                {
                    return String( this->substr(start, end - start + 1) );
                }
            }
            
            template<typename TInsertIterator>
            void split ( TInsertIterator & _ii, const std::string & _delimiters ) const
            {
                if ( this->empty() )
                    return;
            
                std::string::size_type i = 0;
                std::string::size_type j = this->find_first_of(_delimiters);
                while ( j != std::string::npos )
                {
                    *_ii++ = this->substr(i, j - i);
                    i = j + 1;
                    j = find_first_of(_delimiters, i);
                }
            
                // The last field
                *_ii++ = this->substr(i, this->size() - i);
            }
            
            StringList split ( const std::string & _delimiters = " \t\n\r" ) const
            {
                StringList ret;
                std::insert_iterator<StringList> ii (ret, ret.begin());
                split ( ii, _delimiters);
                return ret;
            }

            bool isAlpha () const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::isalpha((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }

            bool isAlphaNumeric () const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::isalnum((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }
            
            bool isUpper() const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::isupper((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }

            bool isLower() const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::islower((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }
            
            bool isDigits() const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::isdigit((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }

            bool isWhitespace() const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::isspace((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }

            bool isHexadecimal() const
            {
                for ( size_type i = 0; i < size(); ++i )
                {
                    if ( !std::isxdigit((*this)[i]) )
                    {
                        return false;
                    }
                }
                return true;
            }

            
            String capitalize () const
            {
                String ret ( this->size(), ' ' );
                ret[0] = toupper((*this)[0]);
                for ( size_type i = 1; i < size(); ++i )
                {
                    ret[i] = tolower((*this)[i]);
                }
                return ret;
            }
            
            String upper () const
            {
                String ret ( this->size(), ' ' );
                for ( size_type i = 0; i < size(); ++i )
                {
                    ret[i] = std::toupper((*this)[i]);
                }
                return ret;
            }
            
            String lower () const
            {
                String ret ( this->size(), ' ' );
                for ( size_type i = 0; i < size(); ++i )
                {
                    ret[i] = std::tolower((*this)[i]);
                }
                return ret;
            }
            
            std::string::value_type & operator[] ( int _index )
            {
                if ( _index < 0 )
                {
                    _index = size() + _index;
                }
                return std::string::operator[] ( _index );
            }

            std::string::value_type operator[] ( int _index ) const
            {
                if ( _index < 0 )
                {
                    _index = size() + _index;
                }
                return std::string::operator[] ( _index );
            }

            template <typename ListType>
            static String join ( const ListType & _list, const String & _seperator )
            {
                return join(_list.begin(), _list.end(), _seperator);
            }
            
            template <typename IteratorType>
            static String join ( const IteratorType & _begin, const IteratorType & _end, const String & _seperator )
            {
                String ret;
                for ( IteratorType it = _begin; it != _end; ++it )
                {
                    if ( it != _begin )
                    {
                        ret += _seperator;
                    }
                    ret += String(*it);
                }
                return ret;
            }
        };
        
        inline void StringList::purgeEmpty ()
        {
            for ( iterator it = begin(); it != end(); )
            {
                if ( it->empty() )
                {
                    it = erase(it);
                }
                else
                {
                    ++it;
                }
            }
        }
        
        inline void StringList::stripAndPurgeEmpty ( const std::string & _letters )
        {
            for ( iterator it = begin(); it != end(); )
            {
                if ( it->strip(_letters).empty() )
                {
                    it = erase(it);
                }
                else
                {
                    ++it;
                }
            }
        }
    }
}

#endif

---