StringFunctions.h File Reference

interfaces of string function More...

#include <string>
#include <boost/function.hpp>
#include <vector>

Include dependency graph for StringFunctions.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	FMT   strfmt

Functions
std::string	strfmt (const char *fmt,...)
	get formated string More...
std::string	wstr2str (std::wstring &ws)
	convert wstring to string More...
std::wstring	str2wstr (std::string &s)
	convert string to wstring More...
std::string	tolowercase (const char *s)
	convert all of the characters in the string given to lower case More...
std::string	touppercase (const char *s)
	convert all of the characters int the string given to upper case More...
int	compareignorecase (const char *s1, const char *s2)
	compare two strings ignoring case considerations More...
unsigned int	stringtoken (const char *s, const char *delim, std::vector< std::string > &tokens)
	get tokens from string More...
unsigned int	stringseparate (const char *s, const char *separator, std::vector< std::string > &tokens)
	separates string More...
bool	isint (const char *s, const int radix=10, int *val=NULL)
	judge whether sutisfied character string shows integer number. More...
int	toint (const char *s, const int radix=10, const int dfval=0)
	convert string into integer More...
bool	isint64 (const char *s, const int radix=10, long long *val=NULL)
	judge whether sutisfied character string shows 64 bit integer number. More...
long long	toint64 (const char *s, const int radix=10, const long long dfval=0)
	convert string into 64 bit integer More...
bool	isdouble (const char *s, double *val=NULL)
	judge whether sutisfied character string shows real number. More...
double	todouble (const char *s, const double dfval=0.0)
	convert string into double More...
bool	tobool (const char *s, bool dfVal=false)
	get true or false from character string. More...
std::string	trimstring (const char *s)
	remove white spaces from both ends of specified string More...
bool	startswith (const char *s, const char *prefix)
	judges whether there is a sub-string at the start of string More...
bool	endswith (const char *s, const char *suffix)
	judge whether there is a sub-string at the end of string More...
std::string	replacestring (const char *s, const char *oldStr, const char *newStr)
	replaces specified substring with another one More...
std::string	shortenstring (const char *s, const unsigned int len, const bool cutTail=true)
	shorten the specified string More...
std::string	regexsearch (const char *s, const char *regex)
	search string using regular expression. More...

Detailed Description

interfaces of string function

Author

S.Tanaka

Date

2006.06.26

Copyright(C) 2006-2014 Eisai Co., Ltd. All rights reserved.

Definition in file StringFunctions.h.

Function Documentation

int compareignorecase	(	const char *	s1,
		const char *	s2
	)

compare two strings ignoring case considerations

Parameters

[in]	s1	the string to compare
[in]	s2	the string to be compared

Returns

- If s1 sorts lexicographically after s2, this function returns greater than zero.

• If s1 sorts lexicographically before s2, this function returns less than zero.
• If two strings match, this function returns zero.

Definition at line 159 of file StringFunctions.cpp.

                                                        {
    return strcmp( tolowercase( s1 ).c_str(), tolowercase( s2 ).c_str() );
}

Here is the call graph for this function:

bool endswith	(	const char *	s,
		const char *	suffix
	)

judge whether there is a sub-string at the end of string

Parameters

[in]	s	string to test
[in]	suffix	sub-string to be checked

Returns

If the sub-string is found at the end of string, this method returns true.

Definition at line 536 of file StringFunctions.cpp.

                                                   {
    // create string object
    std::string str( NVL( s, "" ) );
    std::string sffx( NVL( suffix, "" ) );

    // check
    size_t pos = str.rfind( sffx );

    return ( pos == ( str.length() - sffx.length() ) );
}

bool isdouble	(	const char *	s,
		double *	val
	)

judge whether sutisfied character string shows real number.

Parameters

[in]	s	character string
[out]	val	If sutisfied characgter string is real number, the number is stored in val. If val is NULL, the number is not stored.

Returns

If sutisfied character string shows real number, this function returns true.

Definition at line 406 of file StringFunctions.cpp.

                                            {
    // check parameter
    if( s == NULL ) {
        return false;
    }
        
    // convert
    char* endptr = NULL;
    double v = strtod( s, &endptr );
    if( endptr == s ) {     // not real number
        return false;
    }
    
    // •ÏŠ·‚Å‚«‚È‚©‚Á‚½•¶Žš‚©‚çŒã‚Ì’·‚³‚𒲂ׂé // SPEC 90640
    if( 0 < strlen( endptr ) ){
        // double‚Å‚Í‚È‚¢‚Æ‚Ý‚È‚·
        return false;
    }

    // store value.
    if( val != NULL ) {
        *val = v;
    }
    return true;
}

bool isint	(	const char *	s,
		const int	radix,
		int *	val
	)

judge whether sutisfied character string shows integer number.

Parameters

[in]	s	character string
[in]	radix	radix
[out]	val	If sutisfied character string is integer number, the number is stored in val. If val is NULL, the number is not stored.

Returns

If sutiffied character string shows integer number, this function returns true.

Definition at line 308 of file StringFunctions.cpp.

                                                       {
    // check parameter
    if( s == NULL ) {
        return false;
    }

    // convert
    char* endptr = NULL;
    int v = strtol( s, &endptr, radix );

    if( endptr == s ) {     // not integer
        return false;
    }

    // •ÏŠ·‚Å‚«‚È‚©‚Á‚½•¶Žš‚©‚çŒã‚Ì’·‚³‚𒲂ׂé // SPEC 90640
    if( 0 < strlen( endptr ) ){
        // INT‚Å‚Í‚È‚¢‚Æ‚Ý‚È‚·
        return false;
    }
    
    // store value.
    if( val != NULL ) {
        *val = v;
    }
    return true;
}

bool isint64	(	const char *	s,
		const int	radix,
		long long *	val
	)

judge whether sutisfied character string shows 64 bit integer number.

Parameters

[in]	s	character string
[in]	radix	radix
[out]	val	If sutisfied character string is integer number, the number is stored in val. If val is NULL, the number is not stored.

Returns

If sutiffied character string shows integer number, this function returns true.

Definition at line 354 of file StringFunctions.cpp.

                                                               {
    // check parameter
    if( s == NULL ) {
        return false;
    }

    // convert
    char* endptr = NULL;
    long long v = 0;

#ifdef _MSC_VER
    v = _strtoi64( s, &endptr, radix );
#else
    v = strtoll( s, &endptr, radix );
#endif      // _MSC_VER

    if( endptr == s ) {     // not integer
        return false;
    }

    // store value.
    if( val != NULL ) {
        *val = v;
    }
    return true;
}

std::string regexsearch	(	const char *	s,
		const char *	regex
	)

search string using regular expression.

Parameters

[in]	s	string
[in]	regex	regular expression

Returns

matching string

Definition at line 606 of file StringFunctions.cpp.

                                                          {
    // return value
    std::string ret;

    boost::regex r( regex );
    boost::match_results< const char* > results;
    if( boost::regex_search( s, results, r ) ) {
        ret = results.str( 1 );
    }

    return ret;
}

std::string replacestring	(	const char *	s,
		const char *	oldStr,
		const char *	newStr
	)

replaces specified substring with another one

Parameters

[in]	s	character string to be replaced substring
[in]	oldStr	character string to be replaced
[in]	newStr	character string to replace

Returns

replaced string object

Definition at line 548 of file StringFunctions.cpp.

                                                                                 {
    // create string object
    std::string str;
    if( s == NULL ) {
        return str;
    }
    str = s;

    // check parameters
    if( oldStr == NULL || newStr == NULL ) {
        return str;
    }
    if( strcmp( oldStr, newStr ) == 0 ) {
        return str;
    }

    // find substring
    std::string::size_type pos = str.find( oldStr );
    if( pos == str.npos ) {
        return str;
    }

    // replace
    size_t length = strlen( oldStr );
    str = str.substr( 0, pos ) + std::string( newStr ) + replacestring( s + ( pos + length), oldStr, newStr );

    return str;
}

Here is the call graph for this function:

std::string shortenstring	(	const char *	s,
		const unsigned int	len,
		const bool	cutTail
	)

shorten the specified string

Parameters

[in]	s	source string
[in]	len	maximum the length of string
[in]	cutTail	If true, the tail of the string is cut, otherwise the head of the string is cut.

Returns

shortened string

Definition at line 578 of file StringFunctions.cpp.

                                                                                     {
    // string object
    std::string tmp = NVL( s, "" );

    // check the length
    if( tmp.length() <= len ) {
        return tmp;
    }

    if( len <= 3 ) {
        tmp = "...";
        return tmp;
    }

    // shorten
    if( cutTail ) {
        tmp = tmp.substr( 0, len - 3 );
        tmp.append( "..." );
    }
    else {
        tmp = tmp.substr( 3 );
        tmp = FMT( "...%s", tmp.c_str() );
    }

    return tmp;
}

bool startswith	(	const char *	s,
		const char *	prefix
	)

judges whether there is a sub-string at the start of string

Parameters

[in]	s	string to test
[in]	prefix	sub-string to be checked

Returns

If the sub-string is found at the start of string, this method returns true.

Definition at line 524 of file StringFunctions.cpp.

                                                     {
    // create string object
    std::string str( NVL( s, "" ) );
    std::string prfx( NVL( prefix, "" ) );

    // check
    std::string::size_type pos = str.find( prfx );

    return ( pos == 0 );
}

std::wstring str2wstr

(

std::string &

s

)

convert string to wstring

Parameters

[in]

s

string

Returns

wstring

Definition at line 97 of file StringFunctions.cpp.

                                    {
    // get buffer size
    size_t bufferSize = s.length() + 1;

    // create buffer
    wchar_t* buffer = new wchar_t[ bufferSize ];

    // convert
    size_t size = 0;

#ifdef _MSC_VER
    mbstowcs_s( &size, buffer, bufferSize, s.c_str(), s.size() );
#else
    size = mbstowcs( buffer, s.c_str(), bufferSize );
#endif  // _MSC_VER

    std::wstring ws = std::wstring( buffer );

    delete[] buffer;

    return ws;
}

std::string strfmt	(	const char *	fmt,
			...
	)

get formated string

Parameters

[in]

fmt

format

Returns

formated string

Definition at line 42 of file StringFunctions.cpp.

                                         {
    // definition
    char* s = NULL;
    va_list ap;

    // get string
    va_start( ap, fmt );

#ifdef _MSC_VER

    s = (char*)malloc( STRING_BUFFER_SIZE );
    vsprintf_s( s, STRING_BUFFER_SIZE, fmt, ap );

#else

    vasprintf( &s, fmt, ap );

#endif  // _MSC_VER

    va_end( ap );

    // create std::string object
    std::string s2 = std::string( s );

    // free
    free( s );

    return s2;
}

unsigned int stringseparate	(	const char *	s,
		const char *	separator,
		std::vector< std::string > &	tokens
	)

separates string

Parameters

[in]	s	string
[in]	separator	separator
[out]	tokens	the array to store tokens

Returns

the number of string values

Definition at line 242 of file StringFunctions.cpp.

  {
    // check
    std::string::size_type sepLen = strlen( separator );
    if( sepLen == 0 ) {
        tokens.push_back( s );
        return 1; 
    }

    // string
    std::string str = NVL( s, "" );
    std::list< std::string > strList;

    // double quote
    std::string::size_type start = std::string::npos;
    std::string::size_type pos = 0;
    while( ( pos = str.find(  "\"", ( start == std::string::npos ? 0 : start + 1 ) ) ) != str.npos ) {
        if( start == std::string::npos ) {
            start = pos;
        }
        else {
            strList.push_back( str.substr( start + 1, (int)pos - start - 1 ) );

            std::string tmp = str.substr( 0, start );
            tmp.append( TMP_STRING );
            tmp.append( str.substr( pos + 1 ) );
            str = tmp;

            start = std::string::npos;
        }
    }
    str.append( separator );

    // separate
    std::string::size_type tmpLen = strlen( TMP_STRING );
    std::string::size_type cnt = 0;
    start = 0;
    pos = 0;

    while( ( pos = str.find( separator, start ) ) != str.npos ) {
        // value
        std::string val = str.substr( start, (int)pos - start );

        std::string::size_type rPos = 0;
        while( ( rPos = val.find( TMP_STRING ) ) != val.npos ) {
            std::string tmp = val.substr( 0, rPos );
            tmp.append( strList.front() );
            strList.pop_front();
            tmp.append( val.substr( rPos + tmpLen ) );
            
            val = tmp;
        }

        tokens.push_back( val );
        cnt++;

        start = (int)( pos + sepLen );
    }

    return (unsigned int)cnt;
}

unsigned int stringtoken	(	const char *	s,
		const char *	delim,
		std::vector< std::string > &	tokens
	)

get tokens from string

Parameters

[in]	s	string
[in]	delim	delimiters
[out]	tokens	the array to store tokens

Returns

number of tokens

Definition at line 164 of file StringFunctions.cpp.

 {
    // check
    std::string::size_type delimLen = strlen( delim );
    if( delimLen == 0 ) {
        tokens.push_back( s );
        return 1;
    }

    // string
    std::string str = NVL( s, "" );
    std::list< std::string > strList;

    // double quote
    std::string::size_type start = std::string::npos;
    std::string::size_type pos = 0;
    while( ( pos = str.find(  "\"", ( start == std::string::npos ? 0 : start + 1 ) ) ) != str.npos ) {
        if( start == std::string::npos ) {
            start = pos;
        }
        else {
            strList.push_back( str.substr( start + 1, pos - start - 1 ) );

            std::string tmp = str.substr( 0, start );
            tmp.append( TMP_STRING );
            tmp.append( str.substr( pos + 1 ) );
            str = tmp;

            start = std::string::npos;
        }
    }
    str = FMT( "%s%c", str.c_str(), delim[ 0 ] );

    // separate
    std::string::size_type tmpLen = strlen( TMP_STRING );
    std::string::size_type cnt = 0;
    start = 0;

    for( unsigned int i = 0; i < str.length(); i++ ) {
        // check the character
        char c = str[ i ];
        bool found = false;
        for( unsigned int j = 0; j < delimLen && !found; j++ ) {
            if( c == delim[ j ] ) {
                found = true;
            }
        }

        // add
        if( found ) {
            std::string val = str.substr( start, i - start );

            std::string::size_type rPos = 0;
            while( ( rPos = val.find( TMP_STRING ) ) != val.npos ) {
                std::string tmp = val.substr( 0, rPos );
                tmp.append( strList.front() );
                strList.pop_front();
                tmp.append( val.substr( rPos + tmpLen ) );

                val = tmp;
            }

            if( !val.empty() ) {
                tokens.push_back( val );
                cnt++;
            }

            start = i + 1;
        }
    }

    return (unsigned int)cnt;
}

bool tobool	(	const char *	s,
		bool	dfVal
	)

get true or false from character string.

• If s equals "1", "true" or "on" this method returns true.
• If s equals "0", "false" or "off" this method returns false.
• Otherwise this method returns default value.

  Parameters

  [in]	s	character string
  [in]	dfVal	defaultvalue

  Returns

  boolean value

Definition at line 450 of file StringFunctions.cpp.

                                         {
    // convert to upper case
    std::string value = touppercase( s );

    // get value
    if( value.compare( "1" ) == 0
            || value.compare( "TRUE" ) == 0 || value.compare( "ON" ) == 0 ) {
        return true;
    }
    if( value.compare( "0" ) == 0
            || value.compare( "FALSE" ) == 0 || value.compare( "OFF" ) == 0 ) {
        return false;
    }
    return dfVal;
}

Here is the call graph for this function:

double todouble	(	const char *	s,
		const double	dfval
	)

convert string into double

Parameters

[in]	s	character string converted into double
[in]	dfval	default value

Returns

double value acquired from character string. ( If character string is illegal, this function returns dfval. )

Definition at line 433 of file StringFunctions.cpp.

                                                     {
    // check parameter
    if( s == NULL ) {
        return dfval;
    }

    // convert
    char* endptr = NULL;
    double val = strtod( s, &endptr );
    if( endptr == s ) {     // character string doesn't sho real number.
        val = dfval;
    }

    return val;
}

int toint	(	const char *	s,
		const int	radix,
		const int	dfval
	)

convert string into integer

Parameters

[in]	s	character string converted into integer.
[in]	radix	radix
[in]	dfval	default value

Returns

integer value acquired from character string. ( If character string is illegal, this function returns dfval. )

Definition at line 336 of file StringFunctions.cpp.

                                                             {
    // check parameter
    if( s == NULL ) {
        return dfval;
    }

    // convert
    char* endptr = NULL;
    int val = strtol( s, &endptr, radix );

    if( endptr == s ) {     // character string doesn't show integer number.
        val = dfval;
    }

    return val;
}

long long toint64	(	const char *	s,
		const int	radix,
		const long long	dfval
	)

convert string into 64 bit integer

Parameters

[in]	s	character string converted into integer.
[in]	radix	radix
[in]	dfval	default value

Returns

integer value acquired from character string. ( If character string is illegal, this function returns dfval. )

Definition at line 382 of file StringFunctions.cpp.

                                                                           {
    // check parameter
    if( s == NULL ) {
        return dfval;
    }

    // convert
    char* endptr = NULL;
    long long val = dfval;

#ifdef _MSC_VER
    val = _strtoi64( s, &endptr, radix );
#else
    val = strtoll( s, &endptr, radix );
#endif      // _MSC_VER

    if( endptr == s ) {     // character string doesn't show integer number.
        val = dfval;
    }

    return val;
}

std::string tolowercase

(

const char *

s

)

convert all of the characters in the string given to lower case

Parameters

[in]

s

string before converted to lower case

Returns

the string, converted to lower case

Definition at line 121 of file StringFunctions.cpp.

                                       {
    // string object
    std::string str;
    if( s == NULL ) {
        return str;
    }

    // length
    unsigned int len = (unsigned int)strlen( s );

    // to lower case
    for( unsigned int i = 0; i < len; i++ ) {
        str.push_back( tolower( s[ i ] ) );
    }

    return str;
}

std::string touppercase

(

const char *

s

)

convert all of the characters int the string given to upper case

Parameters

[in]

s

string before converted to upper case

Returns

the string, converted to upper case

Definition at line 140 of file StringFunctions.cpp.

                                       {
    // string object
    std::string str;
    if( s == NULL ) {
        return str;
    }

    // length
    unsigned int len = (unsigned int)strlen( s );

    // to upper case
    for( unsigned int i = 0; i < len; i++ ) {
        str.push_back( toupper( s[ i ] ) );
    }

    return str;
}

std::string trimstring

(

const char *

s

)

remove white spaces from both ends of specified string

Parameters

[in]

s

character string to be trimmed

Returns

trimmed character string

Definition at line 467 of file StringFunctions.cpp.

                                      {
    // string object
    std::string str;

    // check parameter
    if( s == NULL ) {
        return str;
    }

    // create white spaces set
    if( g_whiteSpacesSet.size() == 0 ) {
        size_t num = strlen( g_whiteSpaces );
        for( unsigned int i = 0; i < num; i++ ) {
            g_whiteSpacesSet.insert( g_whiteSpaces[i] );
        }
    }

    // create working buffer
    size_t length = strlen( s );
    size_t size = length + 1;
    char* buffer = new char[ size ];

    // copy character string to buffer
    memcpy( buffer, s, size );

    // trim the front end of string
    char* firstChar = buffer;
    while( g_whiteSpacesSet.find( *firstChar ) != g_whiteSpacesSet.end()
            && *firstChar != '\0' ) {
        firstChar++;
    }

    // trim the back end of string
    char* lastChar = buffer + length;
    if( firstChar != lastChar ) {
        lastChar--;
    }
    while( lastChar != firstChar
            && g_whiteSpacesSet.find( *lastChar ) != g_whiteSpacesSet.end() ) {
        *lastChar = '\0';
        lastChar--;
    }

    // create string object
    std::string trimmed( firstChar );

    // double quote
    if( trimmed.length() >= 2 && trimmed.front() == '\"' && trimmed.back() == '\"' ) {
        trimmed = trimmed.substr( 1, trimmed.length() - 2 );
    }

    delete[] buffer;

    return trimmed;
}

std::string wstr2str

(

std::wstring &

ws

)

convert wstring to string

Parameters

[in]

ws

wstring

Returns

string

Definition at line 73 of file StringFunctions.cpp.

                                     {
    // get buffer size
    size_t bufferSize = ( ws.length() + 1 ) * MB_CUR_MAX;

    // create buffer
    char* buffer = new char[ bufferSize ];

    // convert
    size_t size = 0;

#ifdef _MSC_VER
    wcstombs_s( &size, buffer, bufferSize, ws.c_str(), ws.size() );
#else
    size = wcstombs( buffer, ws.c_str(), size );
#endif  // _MSC_VER

    std::string s = std::string( buffer );

    delete[] buffer;

    return s;
}