---

gnStringTools.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
// File:            gnStringTools.cpp
// Purpose:         Random string manipulation tools
// Description:     Random string manipulation tools
// Changes:        
// Version:         libGenome 0.5.1 
// Author:          Aaron Darling 
// Modified by:     
// Copyright:       (c) Aaron Darling 
// Licenses:        See COPYING file for details
/////////////////////////////////////////////////////////////////////////////
#include "gn/gnStringTools.h"

void BaseCount(const string& bases, gnSeqI& a_count, gnSeqI& c_count, gnSeqI& g_count, gnSeqI& t_count, gnSeqI& other_count){
        a_count = 0;
        c_count = 0;
        g_count = 0;
        t_count = 0;
        other_count = 0;
        for(uint32 i=0; i < bases.length(); i++){
                if((bases[i] == 'a')||(bases[i] == 'A'))
                        a_count++;
                else if((bases[i] == 'c')||(bases[i] == 'C'))
                        c_count++;
                else if((bases[i] == 'g')||(bases[i] == 'G'))
                        g_count++;
                else if((bases[i] == 't')||(bases[i] == 'T'))
                        t_count++;
                else
                        other_count++;
        }
}

// removes white space, keeps only one return for multiple returns
unsigned int removeSpace(string &str)
{
        bool onSpace = true;
        unsigned int nbrSpace = 0;
        bool containsReturn = false;
        unsigned int i;
        for( i = str.length(); i > 0 ; i--)
        {
                if( isspace(str[i-1]) )
                {
                        nbrSpace++;
                        if( (str[i-1] == '\n') || (str[i-1] == '\r') )
                                containsReturn = true;
                        onSpace = true;
                }
                else
                {
                        onSpace = false;
                        if( nbrSpace > 0 )
                        {
                                str.erase( i, nbrSpace-1);
                                str[i] = (containsReturn?'\n':' ');
                        }
                        containsReturn = false;
                        nbrSpace = 0;
                }
        }
        if( nbrSpace > 0 )
        {
                str.erase( i, nbrSpace);
        }
        if( str.length() > 0 )
        {
                if( isspace(str[str.length()-1]) ) str.erase(str.length()-1, 1);
        }
        return nbrSpace;
}

void removeEndSpace(string &str)
{
        unsigned int nbrSpace = 0;
        unsigned int i;
        for( i = str.length()-1; i > 0 ; i--)
        {
                if( !isSpace(str[i]) )
                        break;
                nbrSpace++;
        }
        if( i != str.length() )
        {
                str.erase(i+1, nbrSpace);
        }
}


bool isNewLine(char ch)
{
        if( (ch == '\n') || (ch == '\r') )
        {
                return true;
        }
        return false;
}

bool isWhiteSpace(char ch)
{
        if( (ch == ' ') || (ch == '\t') )
        {
                return true;
        }
        return false;
}

bool isSpace(char ch)
{
        if( isWhiteSpace(ch) || isNewLine(ch) )
        {
                return true;
        }
        return false;
}

string uintToString(unsigned int value)
{
        string str = "";
        char ch = '\0';
        unsigned int b = 0;
        if( value == 0 )
                str = "0";
        while( value != 0 )
        {
                b = value % 10;
                value /= 10;
                ch = b + 48;
                str = ch + str;
        }
        return str;
}
string ulongToString(unsigned long value)
{
        string str = "";
        char ch = '\0';
        unsigned long b = 0;
        if( value == 0 )
                str = "0";
        while( value != 0 )
        {
                b = value % 10;
                value /= 10;
                ch = b + 48;
                str = ch + str;
        }
        return str;
}

unsigned int parseValue(string &valueString)
{
        unsigned int retValue = 0;
        unsigned int length = valueString.length();
        for( unsigned int i=0; i < length;  i++)
        {
                retValue = (retValue * 10) + (valueString[i] - '0');
        }
        return retValue;
}

int parseUintValue(string &valueString)
{
        int retValue = 0;
        unsigned int length = valueString.length();
        for( unsigned int i=0; i < length;  i++)
        {
                if( isdigit( valueString[i] ) )
                {
                        retValue = (retValue * 10) + (valueString[i] - '0');
                }
                else
                        break;
        }
        return retValue;
}

int parseIntValue(string &valueString)
{
        int sign = 1;
        int retValue = 0;
        unsigned int length = valueString.length();
        unsigned int i=0;
        for( ; i < length;  i++)
        {
                if( valueString[i] == '-' )
                {
                        sign = -1;
                        break;
                }
                else if( isdigit( valueString[i] ) )
                {
                        retValue = (retValue * 10) + sign * (valueString[i] - '0');
                        break;
                }
        }
        i++;
        for( ; i < length;  i++)
        {
                if( isdigit( valueString[i] ) )
                {
                        retValue = (retValue * 10) + sign * (valueString[i] - '0');
                }
                else
                        break;
        }
        return retValue;
}

vector< string > tokenizeString( const string &str, char delimiter )
{
        return tokenizeString( str.c_str(), str.length(), delimiter );
}

vector< string > tokenizeString( const char* str, unsigned int len, char delimiter )
{
        unsigned int lastIndex = 0 ;
        vector< string > tokenizeVector;
        unsigned int i=0;
        for( i = 0; i < len ; ++i )
        {
                if( str[i] == delimiter )
                {
                        if( i > (lastIndex + 1) )
                        {
                                tokenizeVector.push_back( string( str + lastIndex, i - lastIndex ) );
                        }
                        lastIndex = i + 1;
                }
        }
        if( i > (lastIndex + 1) )
        {
                tokenizeVector.push_back( string( str + lastIndex, i - lastIndex ) );
        }
        return tokenizeVector;
}


void standarizePathString( string &oFileName )
{
        unsigned int len = oFileName.size();
        for( unsigned int i=0; i < len ; ++i )
        {
                if( oFileName[i] == '\\' )
                        oFileName[i] = '/';
        }
}
string getPathString( string oFileName )
{
        string::size_type i = oFileName.rfind('/');
        if( i != string::npos )
                oFileName.erase(i+1, oFileName.length() - (i+1));
//      else
//              oFileName.clear();
        return oFileName;
}
string getFileString( string oFileName )
{
        string::size_type i = oFileName.rfind('/');
        if( i != string::npos )
                oFileName.erase(0, i + 1);
        return oFileName;
}
string getExtString( string oFileName )
{
        string::size_type i = oFileName.rfind('.');
        if( i != string::npos )
                oFileName.erase( 0, i+1);
//      else
//              oFileName.clear();
        return oFileName;
}

string getFileNoExtString( string oFileName )
{
        string::size_type i = oFileName.rfind('/');
        if( i != string::npos )
                oFileName.erase(0, i + 1);
        i = oFileName.rfind('.');
        if( i != string::npos )
                oFileName.erase( i, string::npos);
        return oFileName;
}

---