FileHandling.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
// must be first:
//#include "precompiled.h"

#define _CRT_SECURE_NO_DEPRECATE
#include <stdio.h>

#include "FileHandling.hh"

#ifdef WIN32
#  include <Base/Common/W32Compat.hh>
#  include <direct.h>
#  include <time.h>
#  include <windows.h>
#else //WIN32
#  include <unistd.h>
#  include <sys/time.h>
#  include <sys/types.h>
#  include <dirent.h>
#  include <dlfcn.h>
#endif //WIN32
#  include <sys/stat.h>
#include <math.h>

// STD
#include <iostream>
#include <fstream>
#include <iomanip> // for std::setw, std::setfill

// BIAS
#include "Base/Debug/Error.hh"

// for transform:
#include <algorithm>
#include <cctype>

#ifdef WIN32
#  include <direct.h> // _getcwd
#endif

using namespace std;
using namespace BIAS;

namespace BIAS
{

  int FileHandling::RemoveDir(const string &subdir)
  {
    string command;
    int res=0;
#ifdef WIN32
    command ="rmdir /S /Q "+subdir;
#else
    command = "rm -rf "+subdir;
#endif
    res = system(command.c_str());
    if (res<0) {
      perror(command.c_str());
      return -1;
    }
    return 0;
  }

  int FileHandling::CreateDir(const string &subdir)
  {
    string command;
    int res=0;
#ifdef WIN32
    command ="md "+subdir;
#else
    command = "mkdir "+subdir;
#endif

    res = system(command.c_str());
    if (res<0) {
      perror(command.c_str());
      return -1;
    }
    return 0;
  }

  int FileHandling::CreateDirRecursive(const string &dir)
  {
    vector<string> parts;
    FileHandling::SplitPath(dir, parts);
    if (!parts.empty())
    {
      // create all subdirectory names
      vector<string> subdirs(parts.size());
#ifdef WIN32
      subdirs[0] = (FileHandling::IsAbsolute(dir) ? "" : ".\\") + parts[0];
#else
      subdirs[0] = (FileHandling::IsAbsolute(dir) ? "/" : "./") + parts[0];
#endif
      for (unsigned int i = 1; i < parts.size(); i++) {
#ifdef WIN32
        subdirs[i] = subdirs[i-1] + "\\" + parts[i];
#else
        subdirs[i] = subdirs[i-1] + "/" + parts[i];
#endif
      }
      // find last existing subdirectory
      int last = (int)subdirs.size()-1;
      while (!FileHandling::FileExists(subdirs[last]) && last >= 0) last--;
      // create all subdirectories from last existing on
      int res = 0;
      for (int j = last+1; j < (int)subdirs.size() && res == 0; j++) {
        res = FileHandling::CreateDir(subdirs[j]);
      }
      return res;
    }
    // nothing to do, return OK (application path is assumed to exist)
    return 0;
  }

  bool FileHandling::FileExists(const string &file)
  {
    struct stat statbuf;
    int res = stat(file.c_str(), &statbuf);

    if (res < 0) return false;
    else return true;
  }

  int FileHandling::GetDirectoryContent(const string &Dir,
                                        const string &prefix,
                                        const string &suffix,
                                        vector<string> &content,
                                        const bool GetFullPath)
  {
    string filename;
    int pl = (int)prefix.length();
    int sl = (int)suffix.length();
    content.clear();

#ifdef WIN32
    std::string tmp = Dir+"/*";

    TCHAR searchPath[MAX_PATH];
    // a wildcard needs to be added to the end of the path, e.g. "C:\*"
    lstrcpy(searchPath, tmp.c_str());
    //   PathAppend(searchPath, "*"); // defined in shell lightweight API (v4.71)

    WIN32_FIND_DATA ffd; // file information struct
    HANDLE sh = FindFirstFile(searchPath, &ffd);
    if(INVALID_HANDLE_VALUE == sh) return -1; // not a proper path i guess

    // enumerate all items; NOTE: FindFirstFile has already got info for an item
    do {
      //std::cout << "Name = " << ffd.cFileName << std::endl;
      //std::cout << "Type = " << ( (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            //  ? "dir\n" : "file\n" );
      //std::cout << "Size = " << ffd.nFileSizeLow << std::endl;
      filename = ffd.cFileName;
      if (filename ==".." || filename==".") continue;

      int l = (int)filename.length();
      if (pl ==0  || (l>=pl && filename.substr(0,pl) == prefix)) {
        if (sl==0 || (l>=sl && filename.substr(l-sl,sl) ==suffix)) {
          if (GetFullPath) content.push_back(Dir+"/"+filename);
          else content.push_back(filename);
        }
      }

    } while (FindNextFile(sh, &ffd));

    FindClose(sh);
#else
    DIR *dp;
    struct dirent *ep;
    dp = opendir (Dir.c_str());
    if (dp == NULL) {
      perror (Dir.c_str());
      return -1;
    }
    while ( (ep = readdir (dp)) != NULL) {
      filename = ep->d_name;
      if (filename ==".." || filename==".") continue;
      //    cout <<Dir<<" filename: "<<filename<<endl;
      int l = filename.length();
      if (pl ==0  || (l >= pl && filename.substr(0,pl) == prefix)) {
        // cout <<"Prefix matched"<<endl;
        if (sl==0 || (l >= sl && filename.substr(l-sl,sl) ==suffix)) {
          //cout <<"Suffix matched"<<endl;
          if (GetFullPath) content.push_back(Dir+"/"+filename);
          else content.push_back(filename);
        }
      }
    }
    (void) closedir (dp);
#endif
    return 0;
  }

  bool FileHandling::FileReadable(const std::string &filename)
  {
    ifstream ifs(filename.c_str());
    // OK determines if file stream could be opened and is readable
    bool ok = ifs.good();
    ifs.close();
    return ok;
  }

  bool FileHandling::CopyFileTo(const std::string &oldFilename,
                                const std::string &newFilename)
  {
    bool res = false;
    std::ifstream fin(oldFilename.c_str(), std::fstream::binary);
    if (fin) {
      std::ofstream fout(newFilename.c_str(), std::fstream::trunc | std::fstream::binary);
      if (fout) {
        fout << fin.rdbuf();
        fout.close();
        res = true;
      }
      fin.close();
    }
    return res;
  }

  void FileHandling::SplitName(const std::string &fullname,
                               string &dir, string &base, string &suffix )
  {
    // find from right, regular expression: dir/subdir/base.ext
#ifdef WIN32
    // separator for directory (both slashes are possible)
    string::size_type tmp1 = fullname.rfind('\\');
    string::size_type tmp2 = fullname.rfind('/');
    string::size_type posL;
    if (tmp1 == std::string::npos)
      posL = tmp2;
    else if (tmp2 == std::string::npos)
      posL = tmp1;
    else
      posL = (tmp1>tmp2)?tmp1:tmp2;
#else
    string::size_type posL = fullname.rfind('/'); // separator for directory
#endif
    string::size_type posR = fullname.rfind('.'); // separator for suffix

    // which separators were found?
    bool foundDir = (posL!=std::string::npos);
    bool foundSuf = (posR!=std::string::npos);

    // bugfix: "." may appear as first character of directory names also,
    // make sure that this is not the case here
    if (foundSuf) {
      if (posR > 0) {
        if (fullname.at(posR-1) == '\\' || fullname.at(posR-1) == '/') {
          foundSuf = false;
        }
      } else {
        foundSuf = false;
      }
    }

    if (foundDir && foundSuf) {
      // found path and suffix, base is inner part
      dir    = fullname.substr(0, posL+1 ); // start, length
      base   = fullname.substr(posL+1, (posR-posL-1)  );
      if (posL<posR)
        suffix = fullname.substr(posR, (fullname.size()-posR)  );
      else
        suffix = "";

    } else if (foundDir && !foundSuf) {
      dir    = fullname.substr(0, posL+1 ); // start, length
      base   = fullname.substr(posL+1, (fullname.size()-posL) );
      suffix = ""; // no suffix found.

    } else if (!foundDir && foundSuf) {
      dir    = "";
      base   = fullname.substr(0, posR);
      suffix = fullname.substr(posR, (fullname.size()-posR) );

    } else {
      // given string is already a basename
      // BIASWARN("Failed to split path, no delimiters found!");
      dir="";
      base=fullname;
      suffix="";
    }
  }

  std::string FileHandling::Directory(const std::string &fullname)
  {
    string dir, base, suf;
    FileHandling::SplitName(fullname, dir, base, suf);
    return dir;
  }

  std::string FileHandling::Basename(const std::string &fullname)
  {
    string dir, base, suf;
    FileHandling::SplitName(fullname, dir, base, suf );
    return base;
  }

  std::string FileHandling::Suffix(const std::string &fullname)
  {
    string dir, base, suf;
    FileHandling::SplitName(fullname, dir, base, suf );
    return suf;
  }

  std::string FileHandling::Extension(const std::string &fullname)
  {
    string suf = Suffix(fullname);
    string ext = suf;

    // remove the dot to get extension from suffix
    string::size_type pos = suf.rfind('.'); // separator
    const bool found = (pos!=std::string::npos);

    // cut the dot if found, keep full extension otherwise
    if (found)
      ext = suf.substr(pos+1, (suf.size()-pos-1) );

    return ext;
  }

  std::string FileHandling::Filename(const std::string &fullname)
  {
    string dir, base, suf;
    FileHandling::SplitName(fullname, dir, base, suf);
    return base+suf;
  }

  std::string FileHandling::DirectoryAndBasename(const std::string &fullname)
  {
    string dir, base, suf;
    FileHandling::SplitName(fullname, dir, base, suf);
    string dir_and_base="";
    if(dir.size()>0){
        dir_and_base = dir;
#ifdef WIN32
        dir_and_base += ('\\');
#else
        dir_and_base += ('/');
#endif
    }
    dir_and_base += base;

    return dir_and_base;
  }

  void FileHandling::SplitPath(const string &fullpath,
                               vector<string> &result)
  {
#ifdef WIN32
    const string delimiters = "\\/";
#else
    const string delimiters = "/";
#endif
    result.clear();
    string str = fullpath;
    string::size_type pos = str.find_first_of(delimiters);
    while (pos != string::npos) {
      if (pos > 0){
        result.push_back(str.substr(0, pos));
      }
      str = str.substr(pos+1);
      pos = str.find_first_of(delimiters);
    }
    if (str.length() > 0) {
      result.push_back(str);
    }
  }

  void FileHandling::LogCommandLine(int argc, char** argv, std::ostream &os)
  {
    for (int i=0; i<argc; i++){
      os<<argv[i]<<" "<<endl;
    }
    os<<endl;
    os<<"argc="<<argc<<endl;
    for (int i=0; i<argc; i++){
      os<<"argv["<<i<<"]="<<argv[i]<<endl;
    }
    os<<flush;
  }

  void FileHandling::LogCommandLine(int argc, char** argv,
                                    const std::string &filename)
  {
    ofstream ofs;
    ofs.open(filename.c_str()); //, ios::app);
    if (!ofs.good()) {
      BIASERR("Failed to open "<<filename<<" for LogCommandLine!")
      LogCommandLine(argc, argv, std::cout);
    } else {
      LogCommandLine(argc, argv, ofs);
    }
    ofs.close();
  }

  std::string FileHandling::LeadingZeroString(const int &n,
                                              const unsigned int &digits )
  {
    return FileHandling::toString(n, digits);
  }

  char FileHandling::ToLower_c(char c) {
    return char(tolower(c));
  }

  char FileHandling::ToUpper_c(char c) {
    return char(toupper(c));
  }

  std::string FileHandling::LowerCase(const std::string &input)
  {
    string s(input);
    // convert each char to lower case
    transform(s.begin(), s.end(), s.begin(), ToLower_c);
    return s;
  }

  std::string FileHandling::UpperCase(const std::string &input)
  {
    string s(input);
    // convert each char to lower case
    transform(s.begin(), s.end(), s.begin(), ToUpper_c);
    return s;
  }

  std::string FileHandling::CurrentDateTimeString()
  {
    time_t tim = time(NULL);
    tm *now = localtime(&tim);
    //     printf("Date is %d/%02d/%02d\n", now->tm_year+1900,
    //            now->tm_mon+1, now->tm_mday);
    //     printf("Time is %02d:%02d\n", now->tm_hour, now->tm_min);

    stringstream sstime;
    sstime << setw(4) << setfill('0') << now->tm_year+1900
        << setw(2) << setfill('0') << now->tm_mon+1
        << setw(2) << setfill('0') << now->tm_mday << "_"
        << setw(2) << setfill('0') << now->tm_hour
        << setw(2) << setfill('0') << now->tm_min
        << setw(2) << setfill('0') << now->tm_sec;

    return sstime.str();
  }


  int FileHandling::ExtractNumberFromRight(const std::string &inStr,
                                           int &number, int &posL, int &posR)
  {
    // parse numeric part of string from right
    number=0;
    posL=posR=0;

    bool done=false;
    bool numericStarted=false;
    //bool numericEnded=false; //unused
    int exp10=0;
    int current = (int)inStr.size()-1;
    while (!done && current>=0)
    {
      const char c=inStr[current];
      switch (c) {
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        { // numerical character: weight digit with current exponent
          if (!numericStarted){
            numericStarted=true;
            posR=current;
          }
          const int act =atoi(&c);
          const int addAct = int(act*pow(10.0, exp10 ));
          number += addAct;
          // next exponent
          exp10++;
          break;
        }
      default:
        { // non-numerical character
          if (numericStarted){
            //bool numericEnded=true; //unused
            posL=current+1;
            done=true;
          }
        }
      }; // switch
      current--;
    }// while

    // found at least one digit?
    if (!numericStarted) {
      //BIASWARN("could not extract digit from "<<inStr);
      return -1;
    }

    return 0;
  }

  int FileHandling::FilenameSequence(const std::string & refFileName,
                                     std::string & resultFilename,
                                     const int & offsetFromRef,
                                     const unsigned int & stepsize )
  {
    // extract directory and extension which are kept
    string dir, base, suffix;
    SplitName(refFileName, dir, base, suffix );

    // extract numeric part of base filename from right
    int actIndex=0; //< act. index
    int posL=0, posR=0; //< cutout positione
    int result=ExtractNumberFromRight(base, actIndex, posL, posR );
    if (result!=0){
      BIASERR("could not extract digit from base="<<base)
      return result; // err.
    }

    // OK
    const int numberOfDigits = posR-posL+1;
    BIASASSERT(numberOfDigits>0);

    // compute new index based on old index
    int newIndex = actIndex +offsetFromRef*stepsize;

    // construct new filename
    string basePrefix  = base.substr(0, posL); // start, length
    string basePostfix = base.substr(posR+1, (base.size()-numberOfDigits));
    resultFilename = dir + (basePrefix + FileHandling::LeadingZeroString(newIndex,numberOfDigits) + basePostfix)
                         + suffix;
    return 0;
  }

  int FileHandling::FilenameExpansion(const std::string &in, std::string & out)
  {
    out = in;
    // replace tilde prefix?
    if (in.size()>1){
      if (in[0]=='~'){
        // like tcsh/bash shell expansion
        string tilde = getenv("HOME");
        if (tilde=="")
        {
          // useful for WIN32: if no HOME is set use HOMEDRIVE+HOMEPATH instead
          string homedrive = getenv("HOMEDRIVE");
          string homepath  = getenv("HOMEPATH");
          //const string profile = getenv("USERPROFILE");
          // replace \ by / to avoid excaped characters
          const char backslash='\\';
          const char fwdslash='/';
          unsigned int n=0;
          for (n=0; n<homedrive.size(); n++)
            if (homedrive[n]==backslash)
              homedrive[n]=fwdslash;
          for (n=0; n<homepath.size(); n++)
            if (homepath[n]==backslash)
              homepath[n]=fwdslash;
          //for (n=0; n<profile.size(); n++)
          //  if (profile[n]==backslash)
          //    profile[n]=fwdslash;

          tilde=homedrive+homepath;
        }
        if (out.size()>0) {
          out.replace(0, 1, tilde); // do replacement
        }
      }
    }
    return 0;
  }

  std::string FileHandling::GetCwd()
  {
    string s;
#if defined(WIN32)
    { // scope of buf
      // NULL triggers dynamic new/allocation by getcwd, works for long NTFS paths
      char * buf = _getcwd( NULL, 0 );
      if (buf==NULL){
        BIASERR("_getcwd error");
        perror( "_getcwd error");
        BIASBREAK;
      } else {
        // copy to std string
        s=buf;
      }
      free(buf);
    }
#else
    char currentdir[1024];
    //getcwd(currentdir, 1024);
    char *cwd = getcwd(currentdir, 1024);
    if (!cwd){
      BIASERR("error getcwd()")
      perror("");
    }
    else s = cwd;
#endif
    return s;
  }

  int FileHandling::ChDir(const std::string &dir)
  {
#ifdef WIN32
    return _chdir(dir.c_str());
#else
    return chdir(dir.c_str());
#endif
  }

  std::string FileHandling::GetApplicationPath()
  {
    string s;
#if defined(WIN32)
    TCHAR szPathName[_MAX_PATH];
    ::GetModuleFileName(NULL, szPathName, _MAX_PATH);
    s = szPathName;
    BIASERR("Module: "<<s);
#else
    BIASERR("not implemented")
#endif
    return s;
  }

}

bool FileHandling::IsAbsolute(const std::string &path)
{
  if (!path.empty()) {
#ifdef WIN32
    return (path.find(string(":\\")) != string::npos);
#else
    return (path[0] == '/');
#endif
  }
  return false;
}