emailrelay/src/glib/gstr.cpp

//
// Copyright (C) 2001 Graeme Walker <graeme_walker@users.sourceforge.net>
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later
// version.
//
// This program 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.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
// ===
//
// gstr.cpp
//

#include "gdef.h"
#include "gstr.h"
#include "gdebug.h"
#include <cmath>
#include <ctype.h>
#include <iomanip>
#include <climits>
#include <string>
#include <sstream>
#include <xlocale>

bool G::Str::replace( std::string &s , const std::string &from ,
	const std::string &to , size_t *pos_p )
{
	if( from.length() == 0 )
		return false ;

	size_t pos = pos_p == NULL ? 0 : *pos_p ;
	if( pos >= s.length() )
		return false ;

	pos = s.find( from , pos ) ;
	if( pos == std::string::npos )
	{
		return false ;
	}
	else
	{
		s.replace( pos , from.length() , to ) ;
		if( pos_p != NULL )
			*pos_p = pos + to.length() ;
		return true ;
	}
}

size_t G::Str::replaceAll( std::string &s , const std::string &from ,
	const std::string &to )
{
	size_t count = 0U ;
	for( size_t pos = 0U ; replace( s , from , to , &pos ) ; count++ )
		; // no-op
	return count ;
}

void G::Str::trimLeft( std::string & s , const std::string & ws )
{
	size_t n = s.find_first_not_of( ws ) ;
	if( n == std::string::npos )
		s = std::string() ;
	else if( n != 0U )
		s.erase( 0U , n ) ;
}

void G::Str::trimRight( std::string & s , const std::string & ws )
{
	size_t n = s.find_last_not_of( ws ) ;
	if( n == std::string::npos )
		s = std::string() ;
	else if( n != 0U )
		s.erase( n+1U , s.length()-n-1U ) ;
}

void G::Str::trim( std::string & s , const std::string & ws )
{
	trimLeft(s,ws) ; trimRight(s,ws) ;
}

bool G::Str::isNumeric( const std::string & s , bool allow_minus_sign )
{
	const char * p = s.c_str() ;
	if( allow_minus_sign && *p == '-' )
		p++ ;

	for( ; *p ; p++ )
	{
		if( *p < '0' || *p > '9' )
			return false ;
	}
	return true ;
}

bool G::Str::isPrintableAscii( const std::string & s )
{
	for( const char * p = s.c_str() ; *p ; p++ )
	{
		if( *p < 0x20 || *p >= 0x7f )
			return false ;
	}
	return true ;
}

bool G::Str::isUShort( const std::string & s )
{
	try
	{
		(void) toUShort(s) ;
	}
	catch( Overflow & )
	{
		return false ;
	}
	catch( InvalidFormat & )
	{
		return false ;
	}
	return true ;
}

bool G::Str::isUInt( const std::string & s )
{
	try
	{
		(void) toUInt(s) ;
	}
	catch( Overflow & )
	{
		return false ;
	}
	catch( InvalidFormat & )
	{
		return false ;
	}
	return true ;
}

bool G::Str::isULong( const std::string & s )
{
	try
	{
		(void) toULong(s) ;
	}
	catch( Overflow & )
	{
		return false ;
	}
	catch( InvalidFormat & )
	{
		return false ;
	}
	return true ;
}

unsigned int G::Str::toUInt( const std::string &s , bool limited )
{
	unsigned long ulong_val = toULong( s ) ;
	unsigned int uint_val = static_cast<unsigned int>( ulong_val ) ;

	if( uint_val != ulong_val )
	{
		if( limited )
			uint_val = UINT_MAX ;
		else
			throw Overflow( s ) ;
	}

	return uint_val ;
}

unsigned long G::Str::toULong( const std::string &s , bool limited )
{
	char * end = NULL ;
	unsigned long result = ::strtoul( s.c_str(), &end, 10 ) ;

	if( end == 0 || end[0] != '\0' )
		throw InvalidFormat( s ) ;

	if( result == ULONG_MAX )
	{
		if( limited )
			result = ULONG_MAX ;
		else
			throw Overflow( s ) ;
	}

	return result ;
}

unsigned short G::Str::toUShort( const std::string &s , bool limited )
{
	unsigned long ulong_val = toULong( s ) ;
	unsigned short ushort_val = static_cast<unsigned short>( ulong_val ) ;

	if( ushort_val != ulong_val )
	{
		if( limited )
			ushort_val = USHRT_MAX ;
		else
			throw Overflow( s ) ;
	}

	return ushort_val ;
}

std::string G::Str::fromUInt( unsigned int n )
{
	std::stringstream ss ;
	ss << n ;
	return ss.str() ;
}

void G::Str::toLower( std::string &s )
{
	for( std::string::iterator p = s.begin() ; p != s.end() ; ++p )
	{
		*p = ::tolower( *p ) ;
	}
}

void G::Str::toUpper( std::string &s )
{
	for( std::string::iterator p = s.begin() ; p != s.end() ; ++p )
	{
		*p = ::toupper( *p ) ;
	}
}

std::string G::Str::toPrintableAscii( char c , char escape )
{
	if( c == escape )
	{
		return std::string( 2U , c ) ;
	}
	else if( c >= 0x20 && c < 0x7f )
	{
		return std::string( 1U , c ) ;
	}

	std::string result( 1U , escape ) ;
	if( c == '\n' )
	{
		result.append( 1U , 'n' ) ;
	}
	else if( c == '\t' )
	{
		result.append( 1U , 't' ) ;
	}
	else if( c == '\0' )
	{
		result.append( 1U , '0' ) ;
	}
	else
	{
		unsigned int n = c ;
		result.append( 1U , char('0'+((n/64U)%8U)) ) ;
		result.append( 1U , char('0'+((n/8U)%8U)) ) ;
		result.append( 1U , char('0'+(n%8U)) ) ;
	}
	return result ;
}

std::string G::Str::toPrintableAscii( const std::string & in , char escape )
{
	std::string result ;
	for( std::string::const_iterator p = in.begin() ; p != in.end() ; ++p )
		result.append( toPrintableAscii(*p,escape) ) ;
	return result ;
}

std::string G::Str::readLineFrom( std::istream & stream , char ignore )
{
	std::string line ;
	char c ;
	while( stream.get(c) ) // ie. while(stream.good())
	{
		if( c == '\n' )
			break ;
		if( ignore != '\0' && c == ignore )
			;
		else
			line.append(1U,c) ;
	}
	return line ;
}

std::string G::Str::readLineFrom( std::istream & stream , const std::string & eol )
{
	std::string result ;
	readLineFrom( stream , eol , result ) ;
	return result ;
}

void G::Str::readLineFrom( std::istream & stream , const std::string & eol , std::string & line )
{
	line.erase() ;

	const size_t eol_length = eol.length() ;
	char c ;
	for( size_t line_length = 1U ; stream.get(c) ; ++line_length )
	{
		line.append(1U,c) ;
		if( line_length >= eol_length )
		{
			const size_t offset = line_length - eol_length ;
			if( line.find(eol,offset) == offset )
			{
				line.erase(offset) ;
				break ;
			}
		}
	}
}

std::string G::Str::wrap( std::string text , const std::string & prefix_1 ,
	const std::string & prefix_2 , size_t width )
{
	std::string ws( " \t\n" ) ;
	std::stringstream ss ;
	for( bool first_line = true ; text.length() ; first_line = false )
	{
		const size_t prefix_length =
			first_line ? prefix_1.length() : prefix_2.length() ;
		size_t w = (width > prefix_length) ? (width-prefix_length) : width ;

		const size_t pos_nl = text.find_first_of("\n") ;
		if( pos_nl != std::string::npos && pos_nl != 0U && pos_nl < w )
		{
			w = pos_nl ;
		}

		std::string line = text ;
		if( text.length() > w )
		{
			line = text.substr( 0U , w ) ;
			if( text.find_first_of(ws,w) != w )
			{
				const size_t white_space = line.find_last_of( ws ) ;
				const size_t black_space = line.find_first_not_of( ws ) ;
				if( white_space != std::string::npos &&
					black_space != std::string::npos &&
					(white_space+1U) != black_space )
				{
					line = line.substr( 0U , white_space ) ;
				}
			}
		}

		if( line.length() != 0U )
		{
			ss << ( first_line ? prefix_1 : prefix_2 ) << line << std::endl ;
		}

		text = text.length() == line.length() ?
			std::string() : text.substr(line.length()) ;

		const size_t black_space = text.find_first_not_of( ws ) ;
		if( black_space != 0U && black_space != std::string::npos )
		{
			size_t newlines = 0U ;
			for( size_t pos = 0U ; pos < black_space ; ++pos )
			{
				if( text.at(pos) == '\n' )
				{
					newlines++ ;
					if( newlines > 1U )
						ss << prefix_2 << std::endl ;
				}
			}

			text = text.substr( black_space ) ;
		}
	}
	return ss.str() ;
}

void G::Str::listPushBack( void * out , const std::string & s )
{
	reinterpret_cast<Strings*>(out)->push_back( s ) ;
}

void G::Str::arrayPushBack( void * out , const std::string & s )
{
	reinterpret_cast<StringArray*>(out)->push_back( s ) ;
}

void G::Str::splitIntoTokens( const std::string &in , Strings &out ,
	const std::string & ws )
{
	splitIntoTokens( in , reinterpret_cast<void*>(&out) ,
		&listPushBack , ws ) ;
}

void G::Str::splitIntoTokens( const std::string &in , StringArray &out ,
	const std::string & ws )
{
	splitIntoTokens( in , reinterpret_cast<void*>(&out) ,
		&arrayPushBack , ws ) ;
}

void G::Str::splitIntoTokens( const std::string & in ,
	void * out , void (*fn)(void*,const std::string&) ,
	const std::string & ws )
{
	for( size_t p = 0U ; p != std::string::npos ; )
	{
		p = in.find_first_not_of( ws , p ) ;
		if( p != std::string::npos )
		{
			size_t end = in.find_first_of( ws , p ) ;
			size_t len = end == std::string::npos ? end : (end-p) ;
			(*fn)( out , in.substr( p , len ) ) ;
			p = end ;
		}
	}
}

void G::Str::splitIntoFields( const std::string & in , Strings &out ,
	const std::string & ws , char escape , bool discard_bogus )
{
	splitIntoFields( in , reinterpret_cast<void*>(&out) ,
		&listPushBack , ws , escape , discard_bogus ) ;
}

void G::Str::splitIntoFields( const std::string & in , StringArray &out ,
	const std::string & ws , char escape , bool discard_bogus )
{
	splitIntoFields( in , reinterpret_cast<void*>(&out) ,
		&arrayPushBack , ws , escape , discard_bogus ) ;
}

void G::Str::splitIntoFields( const std::string & in_in , void * out ,
	void (*fn)(void*,const std::string&) ,
	const std::string & ws , char escape , bool discard_bogus )
{
	std::string all( ws ) ;
	if( escape != '\0' )
		all.append( 1U , escape ) ;

	if( in_in.length() )
	{
		std::string in = in_in ;
		size_t start = 0U ;
		size_t last_pos = in.length() - 1U ;
		size_t pos = 0U ;
		for(;;)
		{
			if( pos >= in.length() ) break ;
			pos = in.find_first_of( all , pos ) ;
			if( pos == std::string::npos ) break ;
			if( in.at(pos) == escape )
			{
				const bool valid =
					pos != last_pos &&
					in.find(all,pos+1U) == (pos+1U) ;

				if( valid || discard_bogus )
					in.erase( pos , 1U ) ;
				else
					pos++ ;
				pos++ ;
			}
			else
			{
				(*fn)( out , in.substr(start,pos-start) ) ;
				pos++ ;
				start = pos ;
			}
		}
		(*fn)( out , in.substr(start,pos-start) ) ;
	}
}