string_filename.cpp

Go to the documentation of this file.

 
#include <unistd.h>             //for get_current_dir_name
#include <dirent.h>             //for opendir
 
#include <sys/stat.h> 
#include <sys/types.h>
 
#include "string_utils.h"
#include "string_system.h"
#include "string_filename.h"
 
using namespace std;
 
 
bool isFileOrDirExist(const std::string & fileName){
        if(fileName == "") return false;
        return access(fileName.c_str(), F_OK) != -1;
}
 
 
bool isFileExist(const std::string & fileName){
        if(fileName == ""){return false;}
        struct stat path_stat;
        if(stat(fileName.c_str(), &path_stat) != 0){
                return false;
        }
        return S_ISREG(path_stat.st_mode) != 0;
}
 
 
 
std::string getExistingFileName(const std::string & fileName, const std::vector<std::string> & vecDirectory){
        if(vecDirectory.size() == 0lu || fileName == ""){return "";}
        std::vector<std::string>::const_iterator it(vecDirectory.begin());
        while(it != vecDirectory.end()){
                std::string tmpFile(*it + "/" + fileName);
                if(isFileExist(tmpFile)){return tmpFile;}
                ++it;
        }
        return "";
}
 
 
bool isDirectoryExist(const std::string & dirName){
        if(dirName == ""){return false;}
        struct stat path_stat;
        if(stat(dirName.c_str(), &path_stat) != 0){
                return false;
        }
        return S_ISDIR(path_stat.st_mode) != 0;
}
 
 
std::string getCurrentDirectory(){
#ifndef __APPLE__
        char* ptr = get_current_dir_name();
        std::string str(ptr);
        free(ptr);
        return str;
#else
        return phoenix_getenv("PWD");
#endif
}
 
 
bool isAbsolutePath(const std::string & path){
        if(path == ""){return false;}
        return path[0] == '/';
}
 
 
std::string makeAbsolutePath(const std::string & path){
        if(path == ""){return getCurrentDirectory() + "/";}
        else if(path[0] == '/'){return path;}
        else{
                return getCurrentDirectory() + "/" + path;
        }
}
 
 
std::vector<std::string> makeAbsolutePath(const std::vector<std::string> & vecPath){
        std::vector<std::string> vecOut;
        for(std::vector<std::string>::const_iterator it(vecPath.begin()); it != vecPath.end(); ++it){
                vecOut.push_back(makeAbsolutePath(*it));
        }
        return vecOut;
}
 
 
std::string removePathDots(const std::string path){
        if(path == ""){return path;}
        if(path.front() == '.'){return path;}
        std::list<std::string> listDir(cutStringList(path, '/'));
        std::list<std::string>::reverse_iterator rit = listDir.rbegin();
        while(rit != listDir.rend()){
                if(*rit == "." || *rit == ""){
//                      rit = listDir.erase(rit);       //No erase in reverse_iterator, so anoying
                        *rit = "";
                }else if(*rit == ".."){
//                      rit = listDir.erase(rit);       //No erase in reverse_iterator, so anoying
                        *rit = "";
                        ++rit;
                        if(rit != listDir.rend()){
//                              rit = listDir.erase(rit);       //No erase in reverse_iterator, so anoying
                                *rit = "";
                        }
                }
//              else{
//                      ++rit;  //No erase in reverse_iterator, so anoying
//              }
                ++rit;
        }
        std::string out(""), separator("");
        if(path[0] == '/'){
                out = "/";
        }
        for(std::list<std::string>::iterator it(listDir.begin()); it != listDir.end(); ++it){
                if(*it == ""){continue;}
                out += separator + (*it);
                separator = "/";
        }
        return out;
}
 
 
std::string getDirectory(const std::string & fileName){
        std::string buffer("");
        bool find(false);
        std::string::const_reverse_iterator rit = fileName.rbegin();
        while(rit != fileName.rend()){
                if(find){
                        buffer = *rit + buffer;
                }else{
                        find = (*rit == '/');
                }
                rit++;
        }
        return buffer;
}
 
 
std::string getUnderPath(const std::string & fileName, const std::string & pathPart){
        if(pathPart == ""){return fileName;}
        std::list<std::string> listDir(cutStringList(fileName, '/'));
        std::list<std::string>::iterator it(listDir.begin());
        bool isSearch(true);
        while(isSearch && it != listDir.end()){
                isSearch = *it != pathPart;
                ++it;
        }
        std::string out(""), separator("");
        while(it != listDir.end()){
                out += separator + (*it);
                separator = "/";
                ++it;
        }
        return out;
}
 
 
std::vector<std::string> getUnderPath(const std::vector<std::string> & vecFileName, const std::string & pathPart){
        std::vector<std::string> vecOut;
        for(std::vector<std::string>::const_iterator it(vecFileName.begin()); it != vecFileName.end(); ++it){
                vecOut.push_back(getUnderPath(*it, pathPart));
        }
        return vecOut;
}
 
 
bool checkFileBegning(const std::string & fileName, const std::string & expectedBegining){
        FILE* fp = fopen(fileName.c_str(), "r");
        if(fp == NULL || expectedBegining.size() == 0lu){return false;}
        int val(0);
        size_t i(0lu);
        bool isMatch(true);
        while(isMatch && !feof(fp) && i < expectedBegining.size()){
                val = fgetc(fp);
                isMatch = (char)val == expectedBegining[i];
                ++i;
        }
        fclose(fp);
        return isMatch;
}
 
 
std::string getFileName(const std::string & fileName){
        std::string buffer("");
        std::string::const_reverse_iterator rit = fileName.rbegin();
        while(rit != fileName.rend()){
                if(*rit == '/') break;
                buffer = *rit + buffer;
                rit++;
        }
        return buffer;
}
 
 
std::string getDirName(const std::string & path){
        std::string buffer("");
        std::string::const_reverse_iterator rit = path.rbegin();
        while(rit != path.rend()){
                if(*rit == '/'){
                        if(buffer != ""){
                                break;
                        }else{
                                rit++;
                                continue;
                        }
                }
                buffer = *rit + buffer;
                rit++;
        }
        return buffer;
}
 
 
std::string getFileContent(const std::string & filename){
        FILE * fp = fopen(filename.c_str(), "r");
        if(fp == NULL){
                std::cerr << "getFileContent : cannot open file '" << filename << "'" << std::endl;
                return "";
        }
        std::string tmp(getFileContent(fp));
        fclose(fp);
        return tmp;
}
 
 
std::string getFileContent(FILE* fp){
        if(fp == NULL) return "";
        std::string bufferAllFile("");
        int buffer;
        while(!feof(fp)){
                buffer = fgetc(fp);
                if(buffer != EOF) bufferAllFile += (char)buffer;
                else break;
        }
        return bufferAllFile;
}
 
 
bool saveFileContent(const std::string & filename, const std::string & content){
        FILE * fp = fopen(filename.c_str(), "w");
        if(fp == NULL){
                std::cerr << "saveFileContent : cannot open file '" << filename << "'" << std::endl;
                return false;
        }
        bool result(saveFileContent(fp, content));
        fclose(fp);
        return result;
}
 
 
bool saveFileContent(FILE* fp, const std::string & content){
        if(fp == NULL) return false;
        fprintf(fp, "%s", content.c_str());
        return true;
}
 
 
std::string getExtention(const std::string & fileName){
        if(!findInString(fileName, '.')) return "";
        std::string extention("");
        bool run(true);
        std::string::const_reverse_iterator rit(fileName.rbegin());
        while(run && rit != fileName.rend()){
                if(*rit == '.' || *rit == '/') run = false;
                else extention = *rit + extention;
                rit++;
        }
        return extention;
}
 
 
std::string getLongestExtention(const std::string & fileName){
        size_t nbPoint(countNbChar(fileName, '.'));
        if(nbPoint == 0lu) return "";
        std::string extention(""), tmpExtention(""), middleDot("");
        bool run(true);
        std::string::const_reverse_iterator rit(fileName.rbegin());
        while(run && rit != fileName.rend()){
                if(*rit == '/'){run = false;}
                else if(*rit == '.'){
                        extention = tmpExtention + middleDot + extention;
                        tmpExtention = "";
                        middleDot = ".";
                }else{
                        tmpExtention = *rit + tmpExtention;
                }
                
                rit++;
        }
        return extention;
}
 
 
std::string eraseExtension(const std::string & fileName){
        int nbPoint(countNbChar(fileName, '.'));
        if(nbPoint == 0) return fileName;
        std::string buffer("");
        int findNbPoint(0);
        std::string::const_iterator it = fileName.begin();
        while(it != fileName.end() && findNbPoint < nbPoint){
                if(*it == '.'){
                        findNbPoint++;
                        if(findNbPoint < nbPoint){
                                buffer += *it;
                        }
                }else{
                        buffer += *it;
                }
                it++;
        }
        return buffer;
}
 
 
std::string eraseLongestExtension(const std::string & fileName){
        std::string longestExtention(getLongestExtention(fileName));
        if(longestExtention != ""){
                return copyStr(fileName, 0lu, fileName.size() - (longestExtention.size() + 1lu));
        }else{
                return fileName;
        }
}
 
 
bool createDirectoriesIfNotExist(const std::string & dirName){
        std::list<std::string> listDir(cutStringList(dirName, '/'));
        std::string tmpDirName("");
        bool isNotFirst(false);
        for(std::list<std::string>::iterator it(listDir.begin()); it != listDir.end(); ++it){
                if(isNotFirst){
                        tmpDirName += "/";
                }
                tmpDirName += *it;
                if(tmpDirName != ""){
                        if(!isDirectoryExist(tmpDirName)){
                                if(mkdir(tmpDirName.c_str(), 0755) != 0){
                                        cerr << "createDirectoryIfNotExist : can't create directory '" << tmpDirName << "'" << endl;
                                        return false;
                                }
                        }
                }
                isNotFirst = true;
        }
        return true;
}