string_system.cpp

Go to the documentation of this file.

 
/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <regex.h>
#include <fcntl.h>      //Definition of AT_* constants
#ifndef __APPLE__
#define GCC_VERSION (__GNUC__ * 10000 \
                    + __GNUC_MINOR__ * 100 \
                    + __GNUC_PATCHLEVEL__)
#       if GCC_VERSION <= 60200
#               include <asm-generic/errno-base.h>
#       endif
#endif
 
#include <time.h>
#include <ctime>
 
#include <sys/types.h>
#include <unistd.h>
 
// #include <cerrno>
#include <iostream>
 
 
#include "string_filename.h"
 
#include "string_system.h"
 
/* From https://nicolasj.developpez.com/articles/regex/
 
[:digit:]       0-9
[:alpha:]       A-Za-z
[:alnum:]       0-9A-Za-z
[:cntrl:]       Les caractères de contrôles (code ASCII 0177 et inférieur à 040)
[:print:]       Les caractères imprimables
[:graph:]       Idem [:print:] sans l'espace
[:lower:]       a-z
[:upper:]       A-Z
[:punct:]       Ni [:cntrl:] ni [:alnum:]
[:space:]       \n\t\r\f
[:xdigit:]      0-9a-fA-F nombres hexadécimaux
 
Ces définitions concordent avec celles que l'on trouve dans le fichier d'en-tête ctype.h. Le point '.' permet de reconnaître n'importe quel caractère. Il est aussi possible de préciser le nombre de répétitions que l'on souhaite pour un élément :
 
Opérateurs      Signification
?               L'élément est répété, au plus une fois
*               L'élément est présent 0 ou plus de fois
+               L'élément est présent au moins une fois
{n}             L'élément est présent exactement n fois
{n,}            L'élément est présent au moins n fois
{n,m}           L'élément est présent entre n et m fois
 
Un élément est un groupe délimité par des crochets qui sont optionnels si le groupe ne comporte qu'un élément. Voici un exemple pour reconnaître si une chaîne contient trois 'a' consécutifs :
 
Sélectionnez
 
[a]{3}
 
L'opposé d'une expression est obtenu en la faisant précéder par le caractère '^'. Si l'on souhaite donner le choix entre deux expressions, il suffit de les séparer par le caractère '|'.
Ce même caractère peut être placé au début de l'expression régulière pour préciser que la chaîne à analyser doit commencer par l'élément suivant :
 
Sélectionnez
 
^[A-Z]
 
Précise que la chaîne doit commencer par une lettre majuscule. Le caractère '$' a le même rôle, mais cette fois en fin de chaîne.
Pour finir, voici la liste des méta caractères ainsi que la manière de les échapper :
 
Méta caractères         Echappés en
        ?               \?
        +               \+
        .               \.
        *               \*
        {               \{
        |               \|
        (               \(
        )               \)
*/
 
 
 
bool isStringMatchRegex(const std::string & str, const std::string & expression){
        if(str.size() == 0lu || expression.size() == 0lu){return false;}
        int err;
        regex_t preg;
        const char *str_request = str.c_str();
        const char *str_regex = expression.c_str();
        err = regcomp(&preg, str_regex, 0);     //REG_NOSUB | REG_EXTENDED
        if(err != 0) return false;
        int match = regexec(&preg, str_request, 0, NULL, 0);
        regfree (&preg);
        if(match == 0){return true;}
        else{return false;}//if (match == REG_NOMATCH){return false;}
//      else{
//              char *text;
//              long unsigned int size;
//              size = regerror (err, &preg, NULL, 0);
//              text = new char[size];
//              if (text){
//                      regerror (err, &preg, text, size);
//                      fprintf (stderr, "isStringMatchRegex : %s\n", text);
//                      delete [] text;
//              }else{
//                      fprintf (stderr, "isStringMatchRegex : Memoire insuffisante\n");
//              }
//              return false;
//      }
}
 
 
void getListFileInCurrentDir(std::list<std::string> & listFile, const std::string & expr){
        char * curr_dir = getenv("PWD");
        if(NULL == curr_dir){
                printf("getListFileInCurrentDir : Could not get the working directory\n");
                return;
        }
        // Open the current directory
        DIR * dp = opendir((const char*)curr_dir);
        if(NULL == dp){
                printf("getListFileInCurrentDir : Could not open the working directory\n");
                return;
        }
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                if(isStringMatchRegex(std::string(dptr->d_name), expr)) listFile.push_back(std::string(dptr->d_name));
                dptr = readdir(dp);
        }
}
 
 
bool getListFileInDir(std::list<std::string> & listFile, const std::string & dirName, const std::string & expr){
        // Open the current directory
        DIR * dp = opendir(dirName.c_str());
        if(NULL == dp){
//              printf("getListFileInDir : Could not open the working directory\n");
                return false;
        }
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                if(isStringMatchRegex(std::string(dptr->d_name), expr)) listFile.push_back(std::string(dptr->d_name));
                std::cout << "getListFileInDir : '" << std::string(dptr->d_name) << "'"<< std::endl;
                dptr = readdir(dp);
        }
        closedir(dp);
        return true;
}
 
 
bool getListAllFileInDir(std::list<std::string> & listFile, const std::string & dirName){
        // Open the current directory
        DIR * dp = opendir(dirName.c_str());
        if(NULL == dp){
                return false;
        }
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                std::string fileName(dptr->d_name);
                if(fileName != ".." && fileName != "."){
                        listFile.push_back(fileName);
                }
                dptr = readdir(dp);
        }
        closedir(dp);
        return true;
}
 
void makeListArgument(std::list<std::string> & listArgument, int argc, char** argv){
        if(argc <= 0) return;
        for(int i(0); i < argc; ++i){
                listArgument.push_back(argv[i]);
        }
}
 
 
std::string phoenix_getenv(const std::string & varName){
        char * curr_var = getenv(varName.c_str());
        if(NULL == curr_var){
                return "";
        }else{
                return std::string(curr_var);
        }
}
 
 
bool phoenix_setenv(const std::string  & name, const std::string & value, int overwrite){
        return setenv(name.c_str(), value.c_str(), overwrite) == 0;
}
 
 
bool phoenix_unsetenv(const std::string & name){
        return unsetenv(name.c_str()) == 0;
}
 
 
std::string getHomeDir(){
        return phoenix_getenv("HOME");
}
 
 
bool createDirIfNotExist(const std::string & directoryName){
        if(directoryName == "") return false;
        if(isDirectoryExist(directoryName)){
                return true;
        }
        int res = mkdir(directoryName.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
        return res == 0 || res == EEXIST;
}
 
 
time_t getFileModificationTime(const std::string & fileName){
        struct stat attr;
        if(stat(fileName.c_str(), &attr) == 0){
#ifdef __APPLE__
                return attr.st_mtimespec.tv_sec;
#else
                return attr.st_mtim.tv_sec;
#endif
        }else{
                return -1l;
        }
}
 
 
time_t getFileInDirPerTime(std::vector<std::string> & vecFile, const std::string & dirName, time_t mostRecentTime){
        DIR * dp = opendir(dirName.c_str());
        if(dp == NULL){return mostRecentTime;}
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                if(dptr->d_type == DT_REG){     //We search for directory only
                        std::string pathName(dptr->d_name);
                        time_t fileTime = getFileModificationTime(dirName + "/" + pathName);
                        if(fileTime > mostRecentTime){
                                mostRecentTime = fileTime;
                                vecFile.push_back(pathName);
                        }
                }
                dptr = readdir(dp);
        }
        return mostRecentTime;
}
 
 
 
std::string getProgramLocation(){
        char buffer[4096];
        ssize_t nbChar = readlink("/proc/self/exe", buffer, 2048);
//      readlink("/proc/self/exe", buf, bufsize) (Linux)
//      readlink("/proc/curproc/file", buf, bufsize) (FreeBSD)
//      readlink("/proc/self/path/a.out", buf, bufsize) (Solaris)
        
        if(nbChar > 0l){
                std::string outputBuf("");
                for(ssize_t i(0l); i < nbChar; ++i){
                        outputBuf += buffer[i];
                }
                return outputBuf;
        }else{
                return "";
        }
}
 
 
std::string getProgramDirectory(){
        std::string progLoc(getProgramLocation());
        if(progLoc != ""){
                return getDirectory(progLoc);
        }else{
#ifdef CMAKE_INSTALL_PREFIX
                return CMAKE_INSTALL_PREFIX "/bin/";
#else
                return "/usr/bin/";
#endif
        }
}
 
 
std::string getProgramPrefix(){
        return getDirectory(getProgramDirectory());
}
 
 
std::string phoenix_popen(const std::string & command){
        if(command == ""){return "";}
        FILE * fp = popen(command.c_str(), "r");
        if(fp == NULL){
                std::cerr << "phoenix_popen : cannot get result of command '"<<command<<"'" << std::endl;
                return "";
        }
        std::string resultCommand(getFileContent(fp));
        pclose(fp);
        return resultCommand;
}
 
 
int phoenix_popen(std::string & executionLog, const std::string & command){
        executionLog = "";
        if(command == ""){return -1;}
        FILE * fp = popen(command.c_str(), "r");
        if(fp == NULL){
                std::cerr << "phoenix_popen : cannot get result of command '"<<command<<"'" << std::endl;
                return -1;
        }
        executionLog = getFileContent(fp);
        return pclose(fp);
}
 
 
bool phoenix_popen(const std::string & executionLogFile, const std::string & command, bool onlyLogOnFail){
        std::string executionLog("");
        bool b(phoenix_popen(executionLog, command) == 0);
        if(!b){
                std::cerr << "phoenix_popen : command '"<<command<<"' failed. To get more information see log '"<<executionLogFile<<"'" << std::endl;
        }
        if((onlyLogOnFail && !b) || !onlyLogOnFail){
                if(!saveFileContent(executionLogFile, executionLog)){
                        std::cerr << "phoenix_popen : cannot create log file '"<<executionLogFile<<"'" << std::endl;
                }
        }
        return b;
}
 
 
bool phoenix_chmod(const std::string & fileName, mode_t __mode){
        bool b(chmod(fileName.c_str(), __mode) >= 0);
        if(!b){
                std::cerr << "phoenix_chmod : Cannot set mode of file '"<<fileName<<"'" << std::endl;
        }
        return b;
}
 
 
std::string getCurrentNodeName(){
        return eraseCharsInStr(phoenix_popen("uname -n"), " \n\t");
}
 
 
void phoenix_find(std::vector<std::string> & vecFile, const std::string & path){
        vecFile = cutStringVector(phoenix_popen("ls " + path), '\n');
}
 
 
std::vector<std::string> phoenix_find(const std::string & path){
        std::vector<std::string> vecFile;
        phoenix_find(vecFile, path);
        return vecFile;
}
 
 
time_t phoenix_getClock(){
        return clock();
}
 
 
double phoenix_getClockSec(){
        return ((double)phoenix_getClock())/((double)CLOCKS_PER_SEC);
}
 
 
time_t phoenix_getTime(){
        return std::time(0);
}
 
 
std::string phoenix_getDate(){
        std::time_t currentTime = phoenix_getTime();
        std::tm* now_tm = std::gmtime(&currentTime);
        char buf[42];
        std::strftime(buf, 42, "%Y/%m/%d : %X", now_tm);
        return buf;
}
 
 
std::string phoenix_getDateCompact(){
        std::time_t currentTime = phoenix_getTime();
        std::tm* now_tm = std::gmtime(&currentTime);
        char buf[42];
        std::strftime(buf, 42, "%Y/%m/%d-%X", now_tm);
        return buf;
}