string.hpp

Go to the documentation of this file.

/*

PICCANTE
The hottest HDR imaging library!
http://vcg.isti.cnr.it/piccante

Copyright (C) 2014
Visual Computing Laboratory - ISTI CNR
http://vcg.isti.cnr.it
First author: Francesco Banterle

This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.

*/

#ifndef PIC_UTIL_STRING_HPP
#define PIC_UTIL_STRING_HPP

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>

#include "../base.hpp"


#ifdef PIC_WIN32
    #include <direct.h>
#endif

#ifndef PIC_WIN32
    #include <unistd.h>
#endif


namespace pic {

#define MAKE_STRING(input_string) #input_string

typedef std::vector<std::string > StringVec;

inline std::string stdStringRep(std::string str, std::string strSub,
                                std::string strRep)
{
    std::string ret = str;

    size_t found = ret.find(strSub);

    if(found != std::string::npos) {
        ret.replace(found, strRep.length(), strRep);
    }

    return ret;
}

inline std::string stdStringRepAll(std::string str, std::string strSub,
                                   std::string strRep)
{
    auto n_sub = strSub.size();
    auto n_rep = strRep.size();

    std::string ret = str;
    std::string::size_type pos = ret.find(strSub);

    while(pos != std::string::npos) {
        ret.replace(pos, n_sub, strRep);

        pos = ret.find(strSub, pos + 1 - n_sub + n_rep);
    }

    return ret;
}

template<class T>
inline std::string fromNumberToString(T num)
{
    std::ostringstream convert;
    convert << num;
    return convert.str();
}

inline char getSeparatorChar(std::string path)
{
    if(path.find("/") != std::string::npos) {
        return '/';
    } else {
        if(path.find("\\") != std::string::npos) {
            return '\\';
        } else {
            return '/';
        }
    }
}

inline std::string removeExtension(std::string name)
{
    std::string tmp(name);
    std::reverse(tmp.begin(), tmp.end());

    size_t pos = tmp.find(".");

    if(pos != std::string::npos) {
        name.erase(name.end() - pos - 1, name.end());
    }

    return name;
}

inline std::string removeLocalPath(std::string name)
{
    std::string toFind(1, getSeparatorChar(name));

    if(toFind.empty()) {
        return name;
    } else {
        size_t oldPos;
        size_t pos = 0;
        do{
            oldPos = pos;
            pos = name.find(toFind, pos + 1);
        } while(pos != std::string::npos);

        name.erase(0, oldPos + 1);
    }

    return name;
}

inline std::string getFileNameOnly(std::string name)
{
    return removeLocalPath(removeExtension(name));
}

inline std::string getExtension(std::string name)
{
    std::string tmp(name);
    std::reverse(tmp.begin(), tmp.end());

    size_t pos = tmp.find(".");
    std::string ext = "";

    if(pos != std::string::npos) {
        auto n = name.length() - pos;
        ext = name.substr(n, n);
    }

    return ext;
}

inline std::string addSuffix(std::string name, std::string suffix)
{
    std::string tmp = removeExtension(name);
    std::string tmpExt = getExtension(name);
    return tmp + suffix + "." + tmpExt;
}

inline std::string replaceExtension(std::string nameOut, std::string fmtIn,
                                std::string fmtOut)
{
    size_t found = nameOut.find(fmtIn);

    if(found != std::string::npos) {
        nameOut.replace(nameOut.begin() + found, nameOut.end(), fmtOut);
    }

    return nameOut;
}

inline int countSubString(std::string str, std::string subStr)
{
    int count = 0;

    std::string::size_type pos = str.find(subStr);

    while(pos != std::string::npos) {
        count++;
        pos = str.find(subStr, pos + 1);
    }

    return count;
}

inline std::string getLocaDirectory(std::string path)
{
    std::string ret = path;

    std::string toFind(1, getSeparatorChar(path));

    if(toFind.empty()) {
        return ret;
    }

    size_t pos1 = path.rfind(toFind);

    if(pos1 != std::string::npos) {
        ret = path.substr(0, pos1);
        size_t pos2 = ret.rfind(toFind);

        if(pos2 != std::string::npos) {
            return ret.substr(pos2 + 1, ret.length());
        }
    }

    return ret;
}

inline std::string getSeparator(std::string path)
{
    char sepChar = getSeparatorChar(path);
    std::string strOut;
    return strOut + sepChar;
}

inline std::string getFolderName(std::string path)
{
    size_t found = path.find_last_of(getSeparator(path));

    if(found != std::string::npos) {
        return path.substr(0, found);
    } else {
        return "./";
    }
}

inline std::string getFileName(std::string path)
{
    std::string toFind;
    std::string ret = path;

    if(path.find("/") != std::string::npos) {
        toFind = "/";
    } else {
        if(path.find("\\") != std::string::npos) {
            toFind = "\\";
        } else {
            return ret;
        }
    }

    size_t pos = path.rfind(toFind);

    if(pos != std::string::npos) {
        ret = path.substr(pos + 1, path.length());
        return ret;
    }

    return ret;
}

inline void parseStringToStdVector(std::string str, char delim,
                                   StringVec *str_vec)
{
    std::stringstream ss(str);

    while(!ss.eof()) {
        std::string tmpStr;
        std::getline(ss, tmpStr, delim);
        str_vec->push_back(tmpStr);
    }
}

inline std::string genBilString(std::string type, float sigma_s,
                                    float sigma_r)
{
    std::string ret = type +
            "_Ss_" + fromNumberToString(sigma_s) +
            "_Sr_" + fromNumberToString(sigma_r);
    return ret;
}

inline std::string fromFileToStdString(std::string nameFile)
{
    std::ifstream infile;
    infile.open(nameFile.c_str(), std::ios::in);

    std::string ret;

    if((!infile.is_open()) || (!infile.good())) {
        return ret;
    }

    int c = infile.get();
    while (infile.good()) {
        ret += c;
        c = infile.get();
    }

    infile.close();

    return ret;
}

inline bool checkAbsolutePath(std::string path)
{
    //win32 absolute path
    if(path.find(":\\") != std::string::npos) {
        return true;
    }

    if(path.find(":/") != std::string::npos) {
        return true;
    }

    if(path.find("\\\\\"") != std::string::npos) {
        return true;
    }

    //unix/mac path
    return (path.at(0) == '/');
}

inline char *fromStdStringToChar(std::string str)
{
    char *cstr = new char [str.size() + 1];
    strcpy (cstr, str.c_str());
    return cstr;
}

inline std::string checkPath(std::string name)
{
    if(name.length() < 3) {
        return "";
    }

    if((name.at(0) == '.') && (name.at(0) == '.')) {
        #ifdef PIC_WIN32
            char *path = _getcwd(NULL, 0);
        #endif

        #ifndef PIC_WIN32
            char *path = getcwd(NULL, 0);
        #endif

        std::string dsepName = getSeparator(name);
        std::string dsepPath = getSeparator(path);

        name = stdStringRepAll(name, dsepName, dsepPath);
        if(name.at(2) == '\\' || name.at(2) == '/') {
            name = name.substr(3);
        } else {
            name = name.substr(2);
        }

        std::string newPath  = path + dsepPath + name;
        return newPath;
    } else {
        return "";
    }
}

std::string adjustPath(std::string nameFile, std::string pathFolder)
{
    if(!checkAbsolutePath(nameFile)) {
        std::string fullPath = checkPath(nameFile);

        if(fullPath.empty()) {
            std::string ret = pathFolder + getSeparator(pathFolder) + nameFile;
            return ret;
        } else {
            return fullPath;
        }
    } else {
        return nameFile;
    }
}

inline std::string removeInitialSpaces(char name[])
{
    size_t pos;
    std::string ret = name;

    pos = ret.find(' ');
    ret.erase(pos, 1);

    pos = ret.find('\n');
    ret.erase(pos, 1);

    return ret;
}

} // end namespace pic

#endif /* PIC_UTIL_STRING_HPP */