stringFuncs.cpp

Go to the documentation of this file.

/*
 *  stringFuncs.cpp - string manipulation routines
 *  Copyright (C) 2014, D Haley 

 *  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 3 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, see <http://www.gnu.org/licenses/>.
*/

#include "atomprobe/helper/stringFuncs.h"

#include "atomprobe/helper/aptAssert.h"


#include <fstream>
#include <ctime>

namespace AtomProbe
{

using std::string;
using std::vector;

std::string onlyFilename( const std::string& path) 
{
#if defined(_WIN32) || defined(_WIN64)
    //windows uses "\" as path sep, just to be different
    return path.substr( path.find_last_of( '\\' ) +1 );
#else
    //The entire world, including the interwebs, uses  "/" as the path sep.
    return path.substr( path.find_last_of( '/' ) +1 );
#endif
}

std::string onlyDir( const std::string& path) 
{
#if defined(_WIN32) || defined(_WIN64)
    //windows uses "\" as path sep, just to be different
    return path.substr(0, path.find_last_of( '\\' ) +1 );
#else
    //The entire world, including the interwebs, uses  "/" as the path sep.
    return path.substr(0, path.find_last_of( '/' ) +1 );
#endif
}

void nullifyMarker(char *buffer, char marker)
{
    while(*(buffer))
    {
        if(*buffer == marker)
        {
            *buffer='\0';
            break;
        }
        buffer++;
    }
}

void ucharToHexStr(unsigned char c, std::string &s)
{
    s="  ";
    char h1,h2;

    h1 = c/16;
    h2 = c%16;

    if(h1 < 10)
    {
        s[0]=(h1+'0');
    }
    else
        s[0]=((h1-10)+'a');

    if(h2 < 10)
    {
        s[1]=(h2+'0');
    }
    else
        s[1]=((h2-10)+'a');
    
}

void hexStrToUChar(const std::string &s, unsigned char &c)
{
    ASSERT(s.size() ==2);

    ASSERT((s[0] >= '0' && s[0] <= '9') ||
                (s[0] >= 'a' && s[0] <= 'f'));
    ASSERT((s[1] >= '0' && s[1] <= '9') ||
            (s[1] >= 'a' && s[1] <= 'f'));

    int high,low;
    if(s[0] <= '9' && s[0] >='0')
        high = s[0]-(int)'0';
    else
        high = s[0] -(int)'a' + 10; 
    
    if(s[1] <= '9' && s[1] >='0')
        low = s[1]-(int)'0';
    else
        low = s[1] -(int)'a' + 10;  

    c = 16*high + low;
}

std::string digitString(unsigned int thisDigit, unsigned int maxDigit)
{
    std::string s,thisStr;
    stream_cast(thisStr,thisDigit);

    stream_cast(s,maxDigit);
    for(unsigned int ui=0;ui<s.size();ui++)
        s[ui]='0';


    s=s.substr(0,s.size()-thisStr.size());  

    return  s+thisStr;
}


//Strip "whitespace"
std::string stripWhite(const std::string &str)
{
    return stripChars(str,"\f\n\r\t ");
}

std::string stripChars(const std::string &str, const char *chars)
{
    using std::string;

    size_t start;
    size_t end;
    if(!str.size())
          return str;

    start = str.find_first_not_of(chars);
    end = str.find_last_not_of(chars);
    if(start == string::npos) 
        return string("");
    else
        return string(str, start, 
                end-start+1);
}

void stripZeroEntries(std::vector<std::string> &sVec)
{
    //Create a truncated vector and reserve mem.
    std::vector<std::string> tVec;
    tVec.reserve(sVec.size());
    std::string s;
    for(unsigned int ui=0;ui<sVec.size(); ui++)
    {
        //Only copy entries with a size.
        if(sVec[ui].size())
        {
            //Push dummy string and swap,
            // to avoid copy
            tVec.push_back(s);
            tVec.back().swap(sVec[ui]);
        }
    }
    //Swap out the truncated vector with the source
    tVec.swap(sVec);
}   

std::string lowercase(std::string s)
{
    for(unsigned int ui=0;ui<s.size();ui++)
    {
        if(isalpha(s[ui]) && isupper(s[ui]))
            s[ui] = tolower(s[ui]);
    }
    return s;
}

//Split strings around a delimiter
void splitStrsRef(const char *cpStr, const char delim,std::vector<string> &v )
{
    const char *thisMark, *lastMark;
    string str;
    v.clear();

    //check for null string
    if(!*cpStr)
        return;
    thisMark=cpStr; 
    lastMark=cpStr;
    while(*thisMark)
    {
        if(*thisMark==delim)
        {
            str.assign(lastMark,thisMark-lastMark);
            v.push_back(str);
        
            thisMark++;
            lastMark=thisMark;
        }
        else
            thisMark++;
    }

    if(thisMark!=lastMark)
    {
        str.assign(lastMark,thisMark-lastMark);
        v.push_back(str);
    }   
        
}

//Split strings around any of a string of delimiters
void splitStrsRef(const char *cpStr, const char *delim,std::vector<string> &v )
{
    const char *thisMark, *lastMark;
    string str;
    v.clear();

    //check for null string
    if(!(*cpStr))
        return;
    thisMark=cpStr; 
    lastMark=cpStr;
    while(*thisMark)
    {
        //Loop over possible delimiters to determine if this char is a delimiter
        bool isDelim;
        const char *tmp;
        tmp=delim;
        isDelim=false;
        while(*tmp)
        {
            if(*thisMark==*tmp)
            {
                isDelim=true;
                break;
            }
            tmp++;
        }
        
        if(isDelim)
        {
            str.assign(lastMark,thisMark-lastMark);
            v.push_back(str);
        
            thisMark++;
            lastMark=thisMark;
        }
        else
            thisMark++;
    }

    if(thisMark!=lastMark)
    {
        str.assign(lastMark,thisMark-lastMark);
        v.push_back(str);
    }   
        
}

bool parseColString(const std::string &str,
    unsigned char &r, unsigned char &g, unsigned char &b, unsigned char &a)
{
    //Input string is in 2 char hex form, 3 or 4 colour, with # leading. RGB order
    //lowercase string.
    if(str.size() != 9 && str.size() != 7)
        return false;

    if(str[0] != '#')
        return false;

    string rS,gS,bS,aS;
    rS=str.substr(1,2);
    gS=str.substr(3,2);
    bS=str.substr(5,2);

    if(!isxdigit(rS[0]) || !isxdigit(rS[1]))
        return false;
    if(!isxdigit(gS[0]) || !isxdigit(gS[1]))
        return false;
    if(!isxdigit(bS[0]) || !isxdigit(bS[1]))
        return false;

    hexStrToUChar(str.substr(1,2),r);   
    hexStrToUChar(str.substr(3,2),g);   
    hexStrToUChar(str.substr(5,2),b);   
    //3 colour must have a=255.
    if(str.size() == 7)
        a = 255;
    else
    {
        aS=str.substr(7,2);
        if(!isxdigit(aS[0]) || !isxdigit(aS[1]))
            return false;
        hexStrToUChar(str.substr(7,2),a);   
    }
    return true;
}

void genColString(unsigned char r, unsigned char g, 
            unsigned char b, std::string &s)
{
    string tmp;
    s="#";
    ucharToHexStr(r,tmp);
    s+=tmp;
    ucharToHexStr(g,tmp);
    s+=tmp;
    ucharToHexStr(b,tmp);
    s+=tmp;
}
}