String utilities

Collaboration diagram for String utilities:

Macros
#define	STR_EQUAL(str1, str2)   (strcmp((str1), (str2)) == 0)

Functions
String	removeChar (const String &str, char character)
String	unescape (const String &str)
int	bestPrecision (float F, int _width)
float	textToFloat (const char *str)
float	textToFloat (const String &str)
int	textToInteger (const char *str)
size_t	textToSizeT (const char *str)
int	textToInteger (const String &str)
long long	textToLongLong (const char *str)
String	floatToString (float F, int _width=8, int _prec=0)
String	integerToString (int I, int _width=0, char fill_with='0')
int	charToInt (const char *str)
String	stringToString (const String &str, size_t _width=0)
void	checkAngle (const String &str)
void	toLower (char *_str)
void	toLower (String &_str)
String	simplify (const String &str)
void	trim (String &str)
String	removeSpaces (const String &_str)
void	removeQuotes (char **_str)
String	findAndReplace (const String &tInput, const String &tFind, const String &tReplace)
String	formatString (const char *format,...)
void	formatStringFast (String &str, const char *format,...)
bool	matchRegExp (const String &inputString, const String &pattern)
String	WordWrap (const String &inputString, size_t lineLength)
String	escapeForRegularExpressions (const String &str)
bool	endsWith (const char *str1, const char *str2)

Tokenization
These functions allow to split a string into small pieces separated by blank spaces, giving you a pointer to the different word each time. The different elements from the string are selected using strtok, so after the application of this function to the input string, this is modified and NULL characters are introduced as delimiters of the elements. This is useful in most situations since after reading a list you might go on reading more things, but you must be aware of it. Here goes an example of doing so: std::cout << "Whole line: " << line << std::endl; std::cout << "First word: " << firstToken(line) << std::endl; std::cout << "Second word: " << nextToken() << std::endl; std::cout << "Third word: " << nextToken() << std::endl; ... When there are no more words, both functions return a NULL pointer. Here we make a distinction between tokens (words that might be empty) and words (words that cannot be empty, if they are then an exception or an exit error is thrown). For STL there is another way. You supply a string object and a vector of strings is returned with all the elements
int	splitString (const String &input, const String &delimiter, StringVector &results, bool includeEmpties=false)
char *	firstToken (const char *str)
char *	firstToken (const String &str)
char *	nextToken ()
String	nextToken (const String &str, size_t &i)
char *	firstWord (char *str)
char *	firstWord (String &str)
char *	nextWord ()
void	tokenize (const String &str, StringVector &tokens, const String &delimiters=" \)
char *	memtok (char **src, char **_end, const char *sep)
void *	_memmem (const void *haystack, size_t haystack_len, const void *needle, size_t needle_len)

Detailed Description

Macro Definition Documentation

STR_EQUAL

#define STR_EQUAL	(		str1,
			str2
	)		(strcmp((str1), (str2)) == 0)

Macro to test if to string are the same

Definition at line 42 of file xmipp_strings.h.

Function Documentation

_memmem()

void* _memmem	(	const void *	haystack,
		size_t	haystack_len,
		const void *	needle,
		size_t	needle_len
	)

Memory string search, taken from GNU C Library

Definition at line 553 of file xmipp_strings.cpp.

{
    if (needle_len == 0)
        /* The first occurrence of the empty string is deemed to occur at
           the beginning of the string.  */
        return (void *) haystack;

    /* Sanity check, otherwise the loop might search through the whole
       memory.  */
    if (haystack_len < needle_len)
        return NULL;

    // memchr
    const char *pNeedle=(const char *) needle;
#ifdef NEVERDEFINED
    const char *const last_possible = (const char *) haystack + haystack_len - needle_len;
    for (const char *begin = (const char *) haystack; begin <= last_possible; ++begin)
        if (begin[0] == pNeedle[0] &&
            !memcmp (begin+1, pNeedle + 1, needle_len - 1))
            return (void *) begin;
#else
    const char *begin=(const char *) haystack;
    const char *current=begin;
    size_t remaining=haystack_len-needle_len+1;
    int firstChar=(int)pNeedle[0];
    while (remaining>0)
    {
        const char *found=(const char *) memchr(current, firstChar, remaining);
        if (found==NULL)
            break;
        else
        {
            if (memcmp(found+1, pNeedle + 1, needle_len - 1)==0)
                return (void *)found;
            else
            {
                remaining-=found-current+1;
                current=found+1;
            }
        }
    }
#endif

    return NULL;
}

bestPrecision()

int bestPrecision	(	float	F,
		int	_width
	)

Best precision for a float number.

This function returns the best precision to be used in a "printf" format if this number is to fit in a given width. It returns -1 if the exponential format is advised.

template<typename T>
std::ostream& operator<<(std::ostream& out, const T& val)
{
    int i,j;

    if (val.xdim == 0)
        out << "NULL matrix" << std::endl;
    else
        out << std::endl;

    T aux = ABSnD(val);
    int prec = bestPrecision(aux.max(), 10);

    for (i=STARTINGY(val); i<=FINISHINGY(val); i++)
    {
        for (j=STARTINGX(val); j<=FINISHINGX(val); j++)
        {
            out << floatToString((float) val(i,j), 10, prec) << ' ';
        }
        out << std::endl;
    }

    return out;
}

Definition at line 176 of file xmipp_strings.cpp.

{
    // If it is 0
    if (F == 0)
        return 1;

    // Otherwise
    int exp = FLOOR(log10(ABS(F)));
    int advised_prec;

    if (exp >= 0)
        if (exp > _width - 3)
            advised_prec = -1;
        else
            advised_prec = _width - 2;
    else
    {
        advised_prec = _width + (exp - 1) - 3;
        if (advised_prec <= 0)
            advised_prec = -1;
    }

    if (advised_prec < 0)
        advised_prec = -1; // Choose exponential format

    return advised_prec;
}

charToInt()

int charToInt

(

const char *

str

)

Character to integer conversion.

Takes a character and produces a number according to its ASCII code minus 48. For instance, ASCII=48 produces number 0, ASCII=49 produces 1, ..., ASCII=57 produces 9, ASCII=58 produces 10!!, ... This is used when you have codified numbers greater than 9 in a single character.

int param_no = textToInt(token, 1602, "Error reading number parameters");

Definition at line 293 of file xmipp_strings.cpp.

{
    if (str == NULL)
        REPORT_ERROR(ERR_MEM_NULLPOINTER, "Cannot convert NULL into int");

    char readval;
    int ok = sscanf(str, "%c", &readval);

    if (ok)
        return readval - 48;
    REPORT_ERROR(ERR_VALUE_INCORRECT, "Conversion to int error");

    return 0;
}

checkAngle()

void checkAngle

(

const String &

str

)

Check angle.

If the argument is not "rot", "tilt" nor "psi" an exception is thrown

Definition at line 320 of file xmipp_strings.cpp.

{
    if (str == "rot")
        return;

    if (str == "tilt")
        return;

    if (str == "psi")
        return;

    REPORT_ERROR(ERR_VALUE_INCORRECT,
                 static_cast< String >(
                     "checkAngle: Not recognized angle type: " + str));
}

endsWith()

bool endsWith	(	const char *	str1,
		const char *	str2
	)

Ends with. Detects if str1 finishes with str2.

Definition at line 684 of file xmipp_strings.cpp.

{
    int len1 = strlen(str1);
    int len2 = strlen(str2);
    return (len1 >= len2) && (0 == strcmp(str1 + len1 - len2, str2));
}

escapeForRegularExpressions()

String escapeForRegularExpressions

(

const String &

str

)

Escape for regular expressions. Escape characters that could be misunderstood by regular expressions

Definition at line 677 of file xmipp_strings.cpp.

{
    String aux;
    aux=findAndReplace(str,"+","\\+");
    return aux;
}

findAndReplace()

String findAndReplace	(	const String &	tInput,
		const String &	tFind,
		const String &	tReplace
	)

Replace. This function replaces in the string all the occurrences of tFind and replaces it with tReplace.

Definition at line 492 of file xmipp_strings.cpp.

{
    size_t uFindLen = tFind.length();

    if( uFindLen == 0 )
        return tInput;

    size_t uPos = 0;
    size_t uReplaceLen = tReplace.length();
    String tOut=tInput;
    for( ;(uPos = tOut.find(tFind, uPos)) != String::npos; )
    {
        tOut=tOut.replace( uPos, uFindLen, tReplace );
        uPos += uReplaceLen;
    }
    return tOut;
}

firstToken() [1/2]

char* firstToken ( const char *  str )

inline

Returns first token (char*).

char line[80];

std::cout << "First  word: " << firstToken(line) << std::endl;

Definition at line 274 of file xmipp_strings.h.

{
    return strtok((char*) str, " \t\n");
}

firstToken() [2/2]

char* firstToken ( const String &  str )

inline

Returns first token (STL).

String line;

std::cout << "First  word: " << firstToken(line) << std::endl;

Definition at line 287 of file xmipp_strings.h.

{
    return strtok((char*) str.c_str(), " \t\n");
}

firstWord() [1/2]

char* firstWord

(

char *

str

)

Get non empty string (char*).

This function returns the first word found in the given line disregarding the leading blanks. If no word is found then an exception or an exit error is produced. After calling this function the first blank character after the word is substituted by a NULL character (as it uses the function firstToken. Further word readings should use the function read_nextWord

Definition at line 453 of file xmipp_strings.cpp.

{
    char *token;

    // Get token
    if (str != NULL)
        token = firstToken(str);
    else
        token = nextToken();

    // Check that there is something
    if (token == NULL)
        REPORT_ERROR(ERR_VALUE_EMPTY, "Empty token");

    return token;
}

firstWord() [2/2]

char* firstWord ( String &  str )

inline

Get non empty string (STL).

Same as the previous function but for STL strings

Definition at line 335 of file xmipp_strings.h.

{
    // FIXME C-style cast
    return firstWord((char*) str.c_str());
}

floatToString()

String floatToString	(	float	F,
		int	_width = 8,
		int	_prec = 0
	)

Float to string conversion.

If precision==0 the precision is automatically computed in such a way that the number fits the width (the exponential format might be chosen). If precision==-1 then the exponential format is forced. If width==0 then the minimum width is used.

REPORT_ERROR(ERR_VALUE_INCORRECT, "Value not recognised " + floatToString(val));

Definition at line 204 of file xmipp_strings.cpp.

{
#if GCC_VERSION < 30300
    char aux[15];
    std::ostrstream outs(aux, sizeof(aux));
#else

    std::ostringstream outs;
#endif

    outs.fill(' ');

    if (_width != 0)
        outs.width(_width);

    if (_prec == 0)
        _prec = bestPrecision(F, _width);

    if (_prec == -1 && _width > 7)
    {
        outs.precision(_width - 7);
        outs.setf(std::ios::scientific);
    }
    else
        outs.precision(_prec);

#if GCC_VERSION < 30301

    outs << F << std::ends;
#else

    outs << F;
#endif

#if GCC_VERSION < 30300

    return String(aux);
#else

    String retval = outs.str();
    int i = retval.find('\0');

    if (i != -1)
        retval = retval.substr(0, i);

    return retval;
#endif
}

formatString()

String formatString	(	const char *	format,
			...
	)

Obtain an string from a format in the way of printf works Example: formatString("vectorHeader@%s",fn_out.c_str())

Definition at line 602 of file xmipp_strings.cpp.

{
    char formatBuffer[1024];
    va_list args;
    va_start(args, format);
    vsprintf (formatBuffer, format, args);
    String result(formatBuffer);
    va_end (args);

    return result;
}

formatStringFast()

void formatStringFast	(	String &	str,
		const char *	format,
			...
	)

Obtain an string from a format in the way of printf works

Definition at line 617 of file xmipp_strings.cpp.

{
    char formatBuffer[1024];

    va_list args;
    va_start(args, format);
    vsprintf (formatBuffer, format, args);
    str=formatBuffer;
    va_end (args);
}

integerToString()

String integerToString	(	int	I,
		int	_width = 0,
		char	fill_with = '0'
	)

Integer to string conversion.

If width==0 then writes the number with the number of digits needed. The fill_with field indicates which is the filling character for the left positions.

REPORT_ERROR(ERR_VALUE_INCORRECT, "Error reading key " + integerToString(key));

Definition at line 253 of file xmipp_strings.cpp.

{
    char aux[15];

    // Check width
    int width = _width;
    int Iaux = ABS(I);

    if (SGN(I) < 0)
        width--;

    if (width == 0)
        do
        {
            Iaux /= 10;
            width++;
        }
        while (Iaux != 0);

    // Fill the number with the fill character
    for (int i = 0; i < width; i++)
        aux[i] = fill_with;

    // Start filling the array
    aux[width--] = '\0';
    Iaux = ABS(I);
    do
    {
        int digit = Iaux % 10;
        Iaux /= 10;
        aux[width--] = '0' + digit;
    }
    while (Iaux != 0);

    if (SGN(I) < 0)
        return static_cast< String >("-")  + aux;
    else
        return static_cast< String >(aux);
}

matchRegExp()

bool matchRegExp	(	const String &	inputString,
		const String &	pattern
	)

True if the inputString matches the regular expression in pattern

Definition at line 629 of file xmipp_strings.cpp.

{
    // Construct regular expression
    regex_t re;
    if (regcomp(&re, pattern.c_str(), REG_EXTENDED|REG_NOSUB) != 0)
        REPORT_ERROR(ERR_ARG_INCORRECT,(String)"Pattern cannot be parsed:"+pattern);

    // Check if the string matches the pattern
    int status = regexec(&re, inputString.c_str(), (size_t) 0, NULL, 0);
    regfree(&re);
    if (status != 0)
        return false;
    return true;
}

memtok()

char* memtok	(	char **	src,
		char **	_end,
		const char *	sep
	)

Tokenizer for char arrays. Similar to strtok but does NOT modify the input array src is a pointer to the array beginning. It may be modified to trim the token _end is a pointer to the end of the token sep is an array with the valid separator

char   *start;
char   *str;
char   *end;
start=(char *) malloc(128);
strcpy(start,"Filtrose    el\tmozo\n en una zahurda lobrega, las paredes\
enhollinadas");
fprintf(stderr,"Mstart=%d",(void *) start);
char aux[64];

str = mystrtok(&start, &end," \t\r\n");
strncpy(aux,str,end-str); aux[end-str]=0;
printf(">%s< %d\n", aux,(void *) end);
str = mystrtok(&start, &end," \t\r\n");
strncpy(aux,str,end-str); aux[end-str]=0;
printf(">%s< %d\n", aux,(void *) end);
str = mystrtok(&start, &end," \t\r\n");
strncpy(aux,str,end-str); aux[end-str]=0;
printf(">%s< %d\n", aux,(void *) end);
str = mystrtok(&start, &end," \t\r\n");
strncpy(aux,str,end-str); aux[end-str]=0;
printf(">%s< %d\n", aux,(void *) end);

Definition at line 525 of file xmipp_strings.cpp.

{
    char   *start = *src;
    char   *end;

    /*
     * Skip over leading delimiters.
     */
    start += strspn(start, sep);
    if (*start == 0)
    {
        *src = start;
        return (0);
    }

    /*
     * Separate off one token.
     */
    end = start + strcspn(start, sep);
    *src = start;
    *_end=end;
    return (start);
}

nextToken() [1/2]

char* nextToken ( )

inline

Returns next token.

This functions returns the next word of the line we have given last as parameter to firstToken.

char line[80];
...
firstToken(line);
std::cout << "Second  word: " << nextToken(line) << std::endl;

stf::string line;
...
firstToken(line);
std::cout << "Second  word: " << nextToken(line) << std::endl;

Definition at line 309 of file xmipp_strings.h.

{
    return strtok((char*) NULL, " \t\n");
}

nextToken() [2/2]

String nextToken	(	const String &	str,
		size_t &	i
	)

Returns next token.

It reads from position i. Returns (in i) the following position to search on. When there are no more tokens. It returns "".

Definition at line 436 of file xmipp_strings.cpp.

{
    String retval;
    if (i >= str.length())
        return retval;
    int j = str.find_first_not_of(" \t\n", i);
    if (j == -1)
        return retval;
    int k = str.find_first_of(" \t\n", j + 1);
    if (k == -1)
        k = str.length();
    retval = str.substr(j, k - j + 1);
    i = k + 1;
    return retval;
}

nextWord()

char* nextWord ( )

inline

Get next non empty string.

This is the same as the nextToken, but an exception is thrown or an exit error produced if the word is empty

Definition at line 346 of file xmipp_strings.h.

{
    return firstWord((char*) NULL);
}

removeChar()

String removeChar	(	const String &	str,
		char	character
	)

Removes all occurrences of 'character' from the string no matter where they are

Definition at line 36 of file xmipp_strings.cpp.

{
    String temp;

    for( unsigned int i = 0 ; i < str.length( ) ; i++ )
    {
        if ( str[ i ] != character )
            temp += str[ i ];
    }

    return temp;
}

removeQuotes()

void removeQuotes

(

char **

_str

)

Remove quotes.

This function removes the first character if it is a double or single quote, as well as the last character. The char pointer might be moved.

char str[10] = "\"Hello\"";
(&str);

Definition at line 363 of file xmipp_strings.cpp.

{
    String retval = *_str;
    if (retval.length() == 0)
        return;
    char c = retval[0];
    if (c == '\"' || c == '\'')
        retval = retval.substr(1, retval.length() - 1);
    c = retval[retval.length()-1];
    if (c == '\"' || c == '\'')
        retval = retval.substr(0, retval.length() - 1);
    free(*_str);
    *_str = strdup(retval.c_str());
}

removeSpaces()

String removeSpaces

(

const String &

_str

)

Remove consecutive spaces.

All consecutive spaces are replaced by a single one and starting and finishing spaces are removed

Definition at line 336 of file xmipp_strings.cpp.

{
    String retval;
    int first = _str.find_first_not_of("\n \t");
    int last = _str.find_last_not_of("\n \t");
    bool after_blank = false;

    for (int i = first; i <= last; i++)
    {
        if (_str[i] == ' ' || _str[i] == '\n' || _str[i] == '\t')
        {
            if (!after_blank)
                retval += _str[i];

            after_blank = true;
        }
        else
        {
            retval += _str[i];
            after_blank = false;
        }
    }

    return retval;
}

simplify()

String simplify

(

const String &

str

)

Removes white spaces from the beginning and the end of the string as well as escaped characters and simplifies the rest of groups of white spaces of the string to a single white space

Definition at line 69 of file xmipp_strings.cpp.

{
    String temp;

    // First, unescape string
    String straux = unescape( str );

    // Remove spaces from the beginning
    int pos = straux.find_first_not_of( ' ' );
    straux.erase( 0, pos );

    // Trim the rest of spaces
    for( unsigned int i = 0 ; i < straux.length( ) ; )
    {
        temp += straux[ i ];

        if ( straux[ i ] == ' ' )
        {
            while( straux[ i ] == ' ' )
            {
                i++;
            }
        }
        else
        {
            i++;
        }
    }

    // Remove space left at the end of the string
    // if needed
    if( temp[ temp.size( ) - 1 ] == ' ' )
    {
        temp.resize( temp.size() - 1 );
    }

    return temp;
}

splitString()

int splitString	(	const String &	input,
		const String &	delimiter,
		StringVector &	results,
		bool	includeEmpties = false
	)

Split a STL string given some delimiter.

Returns a the number of tokens found. The tokens are in the variable results.

Definition at line 379 of file xmipp_strings.cpp.

{
    results.clear();
    size_t delimiterSize = delimiter.size();
    if (input.size()== 0 || delimiterSize == 0)
        return 0;

    size_t newPos, iPos = 0;
    String emptyString;
    while ((newPos = input.find(delimiter, iPos))!=String::npos)
    {
        if (newPos==iPos)
        {
            if (includeEmpties)
                results.push_back(emptyString);
        }
        else
            results.push_back(input.substr(iPos, newPos-iPos));
        iPos = newPos+delimiterSize;
    }
    if (iPos>=input.size())
    {
        if (includeEmpties)
            results.push_back(emptyString);
    }
    else
        results.push_back(input.substr(iPos, String::npos));
    return results.size();
}

stringToString()

String stringToString	(	const String &	str,
		size_t	_width = 0
	)

String to string with given length conversion.

The output string will have the information of the input one with the given width. If the width is smaller than the string length then the string is truncated and if it is greater the string is right padded with spaces. If width==0 then the same string is returned.

Definition at line 308 of file xmipp_strings.cpp.

{
    if (_width == 0)
        return str;

    if (_width < str.length())
        return str.substr(0, _width);

    String aux = str;
    return aux.append(_width - str.length(), ' ');
}

textToFloat() [1/2]

float textToFloat

(

const char *

str

)

String (char*) to float conversion.

float key = textToFloat(firstToken(line), 1602, "Error reading key");

Definition at line 124 of file xmipp_strings.cpp.

{
    if (str == NULL)
        REPORT_ERROR(ERR_MEM_NULLPOINTER, "Cannot be converted into float");

    float retval;
    int ok = sscanf(str, "%f", &retval);

    if (ok)
        return retval;
    REPORT_ERROR(ERR_VALUE_INCORRECT, "Conversion to float error");
}

textToFloat() [2/2]

float textToFloat ( const String &  str )

inline

String (String) to integer conversion.

Definition at line 99 of file xmipp_strings.h.

{
    return textToFloat(str.c_str());
}

textToInteger() [1/2]

int textToInteger

(

const char *

str

)

String (char*) to integer conversion.

int param_no = textToInteger(nextToken(), 1602, "Error reading number parameters")

Definition at line 137 of file xmipp_strings.cpp.

{
    if (str == NULL)
        REPORT_ERROR(ERR_MEM_NULLPOINTER, "Cannot be converted into int");

    int retval;
    int ok = sscanf(str, "%d", &retval);

    if (ok)
        return retval;
    REPORT_ERROR(ERR_VALUE_INCORRECT, "Conversion to int error");
}

textToInteger() [2/2]

int textToInteger ( const String &  str )

inline

String (String) to integer conversion.

Definition at line 116 of file xmipp_strings.h.

{
    return textToInteger(str.c_str());
}

textToLongLong()

long long textToLongLong

(

const char *

str

)

String (char*) to long long integer conversion.

long long param_no = textToLongLong(nextToken(), 1602, "Error reading number
    parameters")

Definition at line 163 of file xmipp_strings.cpp.

{
    if (str == NULL)
        REPORT_ERROR(ERR_MEM_NULLPOINTER, "Cannot be converted into long long int");

    long long int retval;
    int ok = sscanf(str, "%lld", &retval);

    if (ok)
        return retval;
    REPORT_ERROR(ERR_VALUE_INCORRECT, "Conversion to long long int error");
}

textToSizeT()

size_t textToSizeT

(

const char *

str

)

String (String) to size_t conversion.

Definition at line 150 of file xmipp_strings.cpp.

{
    if (str == NULL)
        REPORT_ERROR(ERR_MEM_NULLPOINTER, "Cannot be converted into int");

    long unsigned int retval;
    int ok = sscanf(str, "%lu", &retval);

    if (ok)
        return retval;
    REPORT_ERROR(ERR_VALUE_INCORRECT, "Conversion to size_t error");
}

tokenize()

void tokenize	(	const String &	str,
		StringVector &	tokens
	)

Tokenize a string and return a list of tokens

Definition at line 471 of file xmipp_strings.cpp.

{
    tokens.clear();
    // Skip delimiters at beginning.
    String::size_type lastPos = str.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    String::size_type pos     = str.find_first_of(delimiters, lastPos);

    while (String::npos != pos || String::npos != lastPos)
    {
        // Found a token, add it to the vector.
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        // Skip delimiters.  Note the "not_of"
        lastPos = str.find_first_not_of(delimiters, pos);
        // Find next "non-delimiter"
        pos = str.find_first_of(delimiters, lastPos);
    }
}

toLower() [1/2]

void toLower

(

char *

_str

)

To lower.

All characters between A-Z are brought to a-z. Result is rewritten on input string

Definition at line 413 of file xmipp_strings.cpp.

{
    int i = 0;
    while (_str[i] != '\0')
    {
        if (_str[i] >= 'A' && _str[i] <= 'Z')
            _str[i] += 'a' -'A';
        i++;
    }
}

toLower() [2/2]

void toLower

(

String &

_str

)

To lower, for STL strings.

Definition at line 424 of file xmipp_strings.cpp.

{
    int i = 0;
    while (_str[i] != '\0')
    {
        if (_str[i] >= 'A' && _str[i] <= 'Z')
            _str[i] += 'a' -'A';
        i++;
    }
}

trim()

void trim

(

String &

str

)

Remove trailing spaces

Definition at line 109 of file xmipp_strings.cpp.

{
    String::size_type pos = str.find_last_not_of(' ');

    if (pos != String::npos)
    {
        str.erase(pos + 1);
        pos = str.find_first_not_of(' ');
        if (pos != String::npos)
            str.erase(0, pos);
    }
    else
        str.clear();
}

unescape()

String unescape

(

const String &

str

)

Removes escaped symbols ESC+n, t, v, b, r, f, and a

Definition at line 49 of file xmipp_strings.cpp.

{
    String temp;

    for( unsigned int i = 0 ; i < str.length( ) ; i++ )
    {
        char current_char = str[ i ];

        if( current_char != '\n' && current_char != '\t' &&
            current_char != '\v' && current_char != '\b' &&
            current_char != '\r' && current_char != '\f' &&
            current_char != '\a' )
        {
            temp += str[ i ];
        }
    }

    return temp;
}

WordWrap()

String WordWrap	(	const String &	inputString,
		size_t	lineLength
	)

split long comments in several lines starting with #

Definition at line 645 of file xmipp_strings.cpp.

{

    if(inputString.size() <= lineLength)
        return ((String)"# " + inputString + "\n");
    std::istringstream iss(inputString);
    std::ostringstream ss;
    std::string line;

    line.clear();
    do
    {
        std::string word;
        iss >> word;

        if (line.length() + word.length() > lineLength)
        {
            ss << "# "  << line << std::endl;
            line.clear();
        }
        line += word + " ";

    }
    while (iss);

    if (!line.empty())
    {
        ss << "# "  << line << std::endl;
    }
    return ss.str();
}