/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/fmanip

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_fmanip
#define inlib_fmanip

#include "file"
#include "system"
#include "smanip"
#include "vmanip"
#include "sep"

namespace inlib {

inline bool find_with_dirs(std::ostream& a_out,
                           const std::string& a_dirs,
                           const std::string& a_file,
                           std::string& a_path,
                           bool a_verbose = false ) {
  std::vector<std::string> words;
  inlib::words(a_dirs,psep(),false,words);
  std::vector<std::string>::const_iterator it;
  for(it=words.begin();it!=words.end();++it) {
    a_path = *it;
    a_path += sep();
    a_path += a_file;

    if(a_verbose) {
      a_out << "find_with_dirs :"
            << " look for " << inlib::sout(a_path) << " ..."
            << std::endl;
    }

    if(inlib::file::exists(a_path)) {
      if(a_verbose) {
        a_out << "find_with_dirs :"
              << " found " << inlib::sout(a_path) << "."
              << std::endl;
      }
      return true;
    }
  }
  a_path.clear();

  if(a_verbose) {
    a_out << "find_with_dirs :"
          << " " << inlib::sout(a_file) << " not found."
          << std::endl;
  }

  return false;   
}

inline bool find_with_path(std::ostream& a_out,
                           const std::string& a_env,
                           const std::string& a_file,
                           std::string& a_path,
                           bool a_verbose = false ) {
  std::string PATH;
  if(!inlib::getenv(a_env,PATH)) {
    //look for a a_file in current directory.
    a_path = a_file;
    if(inlib::file::exists(a_path)) return true;
    a_out << "inlib::find_with_path :"
          << " env variable " << sout(a_env) << " not defined."
          << std::endl;
    a_path.clear();
    return false;
  }
  if(a_verbose) {
    a_out << "find_with_path :"
          << " PATH is " << inlib::sout(PATH)
          << std::endl;
  }
  return find_with_dirs(a_out,PATH,a_file,a_path,a_verbose);
}

}

#include "sys/dir"

namespace inlib {

inline bool get_files(std::ostream& a_out,const std::string& a_dirs,const std::string& a_exts,std::vector<std::string>& a_paths) {

  a_paths.clear();

  std::vector<std::string> exts;
  inlib::words(a_exts,"\n",false,exts);

  bool status = true;

  std::vector<std::string> words;
  inlib::words(a_dirs,inlib::psep(),false,words);

  std::vector<std::string>::const_iterator pit;
  for(pit=words.begin();pit!=words.end();++pit) {
    const std::string& dir = *pit;
    bool is_dir;
    if(!inlib::dir::is_a(dir,is_dir)) continue;
    if(!is_dir) continue;
        
    std::vector<std::string> ls;
    if(!inlib::dir::entries(dir,ls,false)){
      a_out << "inlib::get_files :"
            << " can't get entries"
            << " of directory " << inlib::sout(dir) << "."
            << std::endl;
      status = false;
      continue; //continue anyway.
  //} else {
      //a_out << "inlib::get_files :"
      //a_out << "number of files : " << ls.size() << std::endl;
      //std::vector<std::string>::const_iterator it;
      //for(it=ls.begin();it!=ls.end();++it) {
      //  a_out << *it << std::endl;
      //}
    }
    
    std::vector<std::string> files;
   {std::vector<std::string>::const_iterator it;
    for(it=ls.begin();it!=ls.end();++it) {
      if((*it)==".") continue;
      if((*it)=="..") continue;

      std::vector<std::string>::const_iterator eit;
      for(eit=exts.begin();eit!=exts.end();++eit) {
        const std::string& ext = *eit;
        if((*it).rfind(ext)!=std::string::npos) {
          files.push_back(*it);
        }
      }
    }}
      
    std::vector<std::string>::const_iterator it;
    for(it=files.begin();it!=files.end();++it) {
      std::string path = dir+"/"+(*it);
      a_paths.push_back(path);
    }
  }

  inlib::unique(a_paths);
  
  return status;
}

inline bool mkdirs(std::ostream& a_out,const std::string& a_path,bool a_cd = false) {
  //By default it does not "cd" to the leaf directory.
  //In the below, we should treat "absolute" and the case of win_path.
  bool absolute;
  bool win_path;
  std::string drive;
  std::vector<std::string> dirs = path_words(a_path,absolute,win_path,drive);
  if(drive.size()) {
    a_out << "inlib::mkdirs :"
          << " path with a Windows drive not treated yet."
          << std::endl;
    return false;
  }
  if(absolute) {
    a_out << "inlib::mkdirs :"
          << " absolute path not treated yet."
          << std::endl;
    return false;
  }
  std::string spwd;
  if(!a_cd) {
    if(!dir::pwd(spwd)) {
      a_out << "inlib::mkdirs :"
            << " can't get current directory."
            << std::endl;
      return false;
    }
  }  
  bool status = true;
  std::vector<std::string>::const_iterator it;
  for(it=dirs.begin();it!=dirs.end();++it) {
    if(!dir::mkcd(*it)) {
      a_out << "inlib::mkdirs :"
            << " can't mkcd " << sout(*it)
            << std::endl;
      status = false;
      break;
    }
  }
  if(!a_cd) {
    //return to spwd :
    if(!dir::cd(spwd)) {
      a_out << "inlib::mkdirs :"
            << " can't cd to " << spwd << "."
            << std::endl;
      return false;
    }
  }
  return status;
}

}

#endif