PPath.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 <regex.h>
#include <fcntl.h>      //Definition of AT_* constants
 
#include <unistd.h>     //for get_current_dir_name
#include <dirent.h>     //for opendir
 
#include <sys/stat.h> 
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
 
#include "phoenix_env.h"
#include "phoenix_system.h"
#include "PPath.h"
 
 
PString phoenix_getFileContent(FILE* fp){
        if(fp == NULL){return "";}
        //Let's get the size of the file
        fseek(fp, 0, SEEK_END);
        long fileOffset(ftell(fp));
        fseek(fp, 0, SEEK_SET);
        //Is the file is empty we quit
        if(fileOffset == 0l){
                return "";
        }
        //If the size of the file is -1lu this should be a stream which has no defined end yet, such as the popen output
        if(fileOffset == -1l){
                //So we have to use the old method which consist to read the stream character per character until EOF
                //We have to use a std::string instead of PString to have smarter resize strategy
                std::string strBuffer("");
                int buffer;
                while(!feof(fp)){
                        buffer = fgetc(fp);
                        if(buffer != EOF) strBuffer += (char)buffer;
                        else break;
                }
                return strBuffer;
        }else{
                size_t fileSize(fileOffset);
                //If we know the size of the file, we can resize our PString once for all and load the content with fread
                PString bufferAllFile;
                bufferAllFile.resize(fileSize);
                if(fread(bufferAllFile.data(), sizeof(char), fileSize, fp) == fileSize){
                        
                }
                return bufferAllFile;
        }
}
 
 
PPath::PPath()
        :PString()
{
        initialisationPPath();
}
 
 
PPath::PPath(const PString & other)
        :PString(other)
{
        initialisationPPath();
}
 
 
PPath::PPath(const PPath & other)
        :PString(other)
{
        copyPPath(other);
}
 
PPath::~PPath(){
        
}
 
 
PPath & PPath::operator = (const PPath & other){
        copyPString(other);
        copyPPath(other);
        return *this;
}
 
 
PPath operator + (const PPath & other1, const PPath & other2){
        PPath out(other1);
        out += other2;
        return out;
}
 
 
PPath operator / (const PPath & other1, const PPath & other2){
        PPath out(other1);
        if(other1.size() != 0lu){
                out += PString("/");
        }
        out += other2;
        return out;
}
 
 
bool PPath::isExist() const{
        if(size() == 0lu) return false;
        return access(c_str(), F_OK) != -1;
}
 
 
bool PPath::isFileExist() const{
        if(size() == 0lu) return false;
        struct stat path_stat;
        if(stat(c_str(), &path_stat) != 0){
                return false;
        }
        return S_ISREG(path_stat.st_mode) != 0;
}
 
 
bool PPath::isDirectoryExist() const{
        if(size() == 0lu) return false;
        struct stat path_stat;
        if(stat(c_str(), &path_stat) != 0){
                return false;
        }
        return S_ISDIR(path_stat.st_mode) != 0;
}
 
 
bool PPath::isAbsolutePath() const{
        if(size() == 0lu) return false;
        return front() == '/';
}
 
 
PPath PPath::getFileName() const{
        std::string buffer("");
        std::string::const_reverse_iterator rit = rbegin();
        while(rit != rend()){
                if(*rit == '/') break;
                buffer = *rit + buffer;
                rit++;
        }
        return PPath(buffer);
}
 
 
PPath PPath::getDirectoryName() const{
        std::string buffer("");
        std::string::const_reverse_iterator rit = rbegin();
        while(rit != rend()){
                if(*rit == '/'){
                        if(buffer != ""){
                                break;
                        }else{
                                rit++;
                                continue;
                        }
                }
                buffer = *rit + buffer;
                rit++;
        }
        return PPath(buffer);
}
 
 
PPath PPath::getParentDirectory() const{
        if(size() == 0lu){return PString("");}
        std::string buffer("");
        bool find(false), isLastSlash(back() == '/');
        std::string::const_reverse_iterator rit = rbegin();
        while(rit != rend()){
                if(find){
                        buffer = *rit + buffer;
                }else{
                        find = (*rit == '/' && !isLastSlash);
                        isLastSlash = *rit == '/';
                }
                rit++;
        }
        return PPath(buffer);
}
 
 
PPath PPath::getParentDirectory(const PPath & subDirName) const{
        if(size() == 0lu || !isDirectoryExist()){return *this;}
        PPath curDir(*this);
        std::string tmp(curDir / subDirName);
        DIR * dp = opendir(tmp.c_str());
        while(NULL == dp && curDir.size() > 1lu){
                curDir = curDir.getParentDirectory();
                tmp = curDir / subDirName;
                dp = opendir(tmp.c_str());
        }
        return curDir;
        
        
//      PPath curDir(*this);
//      PPath tmpDir(curDir / subDirName);
//      while(!curDir.isDirectoryExist() && curDir.size() > subDirName.size()){
//              curDir = curDir.getParentDirectory() / subDirName;
//      }
//      return curDir;
}
 
 
PString PPath::getExtension() const{
        if(!find('.')) return "";
        std::string extension("");
        bool run(true);
        std::string::const_reverse_iterator rit(rbegin());
        while(run && rit != rend()){
                if(*rit == '.' || *rit == '/') run = false;
                else extension = *rit + extension;
                rit++;
        }
        return PString(extension);
}
 
 
PString PPath::getLongestExtension() const{
        size_t nbPoint(count('.'));
        if(nbPoint == 0lu) return "";
        PString extension(""), tmpExtension(""), middleDot("");
        bool run(true);
        PString::const_reverse_iterator rit(rbegin());
        while(run && rit != rend()){
                if(*rit == '/'){run = false;}
                else if(*rit == '.'){
                        extension = tmpExtension + middleDot + extension;
                        tmpExtension = "";
                        middleDot = ".";
                }else{
                        tmpExtension = *rit + tmpExtension;
                }
                
                rit++;
        }
        return extension;
}
 
 
PPath & PPath::eraseExtension(){
        if(size() <= 1lu){return *this;}
        PString extension(getExtension());
        if(extension.size() == 0lu){return *this;}
        resize(size() - extension.size() - 1lu);
        return *this;
}
 
 
PPath & PPath::eraseLongestExtension(){
        if(size() <= 1lu){return *this;}
        PString extension(getLongestExtension());
        if(extension.size() == 0lu){return *this;}
        resize(size() - extension.size() - 1lu);
        return *this;
}
 
 
PPath PPath::eraseExtension() const{
        PPath out(*this);
        return out.eraseExtension();
}
 
 
PPath PPath::eraseLongestExtension() const{
        PPath out(*this);
        return out.eraseLongestExtension();
}
 
 
bool PPath::createDirectory(mode_t mode) const{
        if(size() == 0lu){return false;}
        else if(isDirectoryExist()){return true;}
        
        std::vector<PString> listDir(split('/'));
        PPath tmpDirName;
        bool isNotFirst(false);
        for(std::vector<PString>::iterator it(listDir.begin()); it != listDir.end(); ++it){
                if(isNotFirst){
                        tmpDirName += "/";
                }
                tmpDirName += *it;
                if(tmpDirName != ""){
                        if(!tmpDirName.isDirectoryExist()){
                                if(mkdir(tmpDirName.c_str(), mode) != 0){
                                        return false;
                                }
                        }
                }
                isNotFirst = true;
        }
        return true;
//      return mkdir(c_str(), 0755) == 0;
}
 
 
PPath PPath::getUnderPath(const PString & pathPart) const{
        if(pathPart.size() == 0lu){return *this;}
        std::vector<PString> listDir(split('/'));
        std::vector<PString>::iterator it(listDir.begin());
        bool isSearch(true);
        while(isSearch && it != listDir.end()){
                isSearch = *it != pathPart;
                ++it;
        }
        PPath out;
        PString separator("");
        while(it != listDir.end()){
                out += separator + (*it);
                separator = "/";
                ++it;
        }
        return out;
}
 
 
PString PPath::loadFileContent() const{
        if(!isFileExist()){return "";}
        FILE * fp = fopen(c_str(), "r");
        if(fp == NULL){return "";}
        PString bufferAllFile(phoenix_getFileContent(fp));
        fclose(fp);
        return bufferAllFile;
}
 
 
bool PPath::saveFileContent(const PString & content) const{
        FILE * fp = fopen(c_str(), "w");
        if(fp == NULL){return false;}
        bool result(true);
        fprintf(fp, "%s", content.c_str());
        fclose(fp);
        return result;
}
 
 
size_t PPath::getFileSize() const{
        FILE* fs = fopen(c_str(), "r");
        if(fs == NULL){return 0lu;}
        fseek(fs, 0, SEEK_END);
        size_t fileSize(ftell(fs));
        fseek(fs, 0, SEEK_SET);
        fclose(fs);
        return fileSize;
}
 
 
bool PPath::checkFileBegning(const PString & expectedBegining) const{
        if(size() == 0lu){return false;}
        FILE* fp = fopen(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;
}
 
 
time_t PPath::getFileModificationTime() const{
        struct stat attr;
        if(stat(c_str(), &attr) == 0){
#ifdef __APPLE__
                return attr.st_mtimespec.tv_sec;
#else
                return attr.st_mtim.tv_sec;
#endif
        }else{
                return -1l;
        }
}
 
 
std::vector<PPath> PPath::getAllFileInDir() const{
        std::vector<PPath> listFile;
        // Open the current directory
        DIR * dp = opendir(c_str());
        if(NULL == dp){
                return listFile;
        }
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                if(dptr->d_type == DT_REG){
                        PPath fileName(dptr->d_name);
                        listFile.push_back(fileName);
                }
                dptr = readdir(dp);
        }
        closedir(dp);
        return listFile;
}
 
 
std::vector<PPath> PPath::getAllDirectoryInDir() const{
        std::vector<PPath> listFile;
        // Open the current directory
        DIR * dp = opendir(c_str());
        if(NULL == dp){
                return listFile;
        }
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                if(dptr->d_type == DT_DIR){
                        PPath dirName(dptr->d_name);
                        if(dirName != ".." && dirName != "."){
                                listFile.push_back(dirName);
                        }
                }
                dptr = readdir(dp);
        }
        closedir(dp);
        return listFile;
}
 
 
std::vector<PPath> PPath::getAllElementInDir() const{
        std::vector<PPath> listFile;
        // Open the current directory
        DIR * dp = opendir(c_str());
        if(NULL == dp){
                return listFile;
        }
        dirent * dptr = readdir(dp);
        while(NULL != dptr){
                PPath fileName(dptr->d_name);
                if(fileName != ".." && fileName != "."){
                        listFile.push_back(fileName);
                }
                dptr = readdir(dp);
        }
        closedir(dp);
        return listFile;
}
 
 
bool PPath::changeMode(mode_t __mode) const{
        return chmod(c_str(), __mode) >= 0;
}
 
 
PPath PPath::simplify() const{
        if(size() == 0lu){return *this;}
        if(front() == '.'){return *this;}
        std::vector<PString> listDir(split('/'));
        std::vector<PString>::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;
        }
        PPath out;
        PString separator("");
        if(front() == '/'){
                out = PString("/");
        }
        for(std::vector<PString>::iterator it(listDir.begin()); it != listDir.end(); ++it){
                if(*it == ""){continue;}
                out += separator + (*it);
                separator = "/";
        }
        return out;
}
 
 
PPath PPath::makeAbsolute() const{
        if(size() == 0lu){
                return PPath::getCurrentDirectory().add("/");
        }else if(isAbsolutePath()){
                return *this;
        }else{
                return PPath::getCurrentDirectory().add("/").add(*this);
        }
}
 
 
PPath PPath::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){
                PString outputBuf("");
                for(ssize_t i(0l); i < nbChar; ++i){
                        outputBuf += buffer[i];
                }
                return outputBuf;
        }else{
                return PString("");
        }
}
 
 
PPath PPath::getProgramDirectory(){
        PPath progLoc(getProgramLocation());
        if(progLoc != ""){
                return progLoc.getParentDirectory();
        }else{
#ifdef CMAKE_INSTALL_PREFIX
                return PString(CMAKE_INSTALL_PREFIX "/bin/");
#else
                return PString("/usr/bin/");
#endif
        }
}
 
 
PPath PPath::getProgramPrefix(){
        return getProgramDirectory().getParentDirectory();
}
 
 
PPath PPath::getHomeDir(){
        return phoenix_getenv("HOME");
}
 
 
PPath PPath::getCurrentDirectory(){
#ifndef __APPLE__
        char* ptr = get_current_dir_name();
        PString str(phoenix_charToString(ptr));
        free(ptr);
        return str;
#else
        return phoenix_getenv("PWD");
#endif
}
 
 
PString PPath::getCurrentNodeName(){
        return phoenix_popen("uname -n").eraseChar(" \n\t");
}
 
 
void PPath::copyPPath(const PPath & other){
        
}
 
void PPath::initialisationPPath(){
        
}