fileUtils.cpp

Go to the documentation of this file.

/** \file fileUtils.cpp
  * \brief Definitions of utilities for working with files
  *
  * \author Jared R. Males (jaredmales@gmail.com)
  *
  * \ingroup fileutils
  *
  */
 
//***********************************************************************//
// Copyright 2020 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "ioutils/fileUtils.hpp"
 
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <libgen.h>
#include <cmath>
#include <algorithm>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include <boost/filesystem.hpp>
 
using namespace boost::filesystem;
 
namespace mx
{
namespace ioutils
{
 
int createDirectories( const std::string & path )
{
   //Use the non throwing version and silently ignore EEXIST errors 
   boost::system::error_code ec;
   boost::filesystem::create_directories(path, ec);
   if(ec.value() != boost::system::errc::success && ec.value() != boost::system::errc::file_exists)
   {
      return -1;
   }
 
   return 0;
}
 
std::string pathStem(const std::string & fname)
{
   boost::filesystem::path p(fname);
   return p.stem().string();
}
 
std::string pathFilename( const std::string & fname)
{
   boost::filesystem::path p(fname);
   return p.filename().string();
}
 
std::string parentPath(const std::string & fname)
{
   boost::filesystem::path p(fname);
   return p.parent_path().string();
}
 
 
 
std::vector<std::string> getFileNames( const std::string & directory, 
                                       const std::string & prefix,    
                                       const std::string & substr,    
                                       const std::string & extension  
                                     )
{
   typedef std::vector<path> vec;             // store paths,
 
   std::vector<std::string> vect;
   if( exists(directory) )
   {
      if(is_directory(directory) )
      {
         vec v;                                // so we can sort them later
 
         copy(directory_iterator(directory), directory_iterator(), back_inserter(v));
 
         std::sort(v.begin(), v.end());             // sort, since directory iteration
                                              // is not ordered on some file systems
 
         auto it = v.begin();
         auto it_end = v.end();
 
         while(it != it_end)
         {
            bool inc = true;
 
            if(extension != "")
            {
               if(it->extension() != extension)
               {
                  inc = false;
               }
            }
 
            if(prefix != "" && inc)
            {
               std::string p = it->filename().generic_string();
 
               if( p.size() < prefix.size() )
               {
                  inc = false;
               }
               else
               {
                  if(p.compare(0, prefix.size(), prefix) != 0)
                  {
                     inc = false;
                  }
               }
            }
 
            if(substr != "" && inc)
            {
               std::string p = it->filename().generic_string();
               if(p.find(substr) == std::string::npos)
               {
                  inc = false;
               }
            }
 
            if(inc)
            {
               vect.push_back(it->native());
            }
 
            ++it;
         }
      }
      else
      {
         std::cerr << directory << " is not a directory\n";
      }
 
   }
   else
   {
      std::cerr << "directory " << directory << " does not exist\n";
   }
 
   return vect;
}
 
std::vector<std::string> getFileNames( const std::string & directory, 
                                       const std::string & extension  
                                     )
{
   return getFileNames(directory, "", "", extension);
}
 
std::vector<std::string> getFileNames( const std::string & directory )
{
   return getFileNames(directory, "", "", "");
}
 
 
std::string  fileNamePrependAppend( const std::string & fname,   
                                    const std::string & prepend, 
                                    const std::string & append   
                                  )
{
   std::string dir, base, ext;
 
   path p = fname;
   dir = p.parent_path().string();
   base = p.stem().string();
   ext = p.extension().string();
 
 
   return dir +'/' + prepend + base + append + ext;
 
 
}
 
std::string  fileNameAppend( const std::string & fname, 
                             const std::string & append
                           )
{
   return fileNamePrependAppend(fname, "", append);
}
 
std::string  fileNamePrepend( const std::string & fname, 
                              const std::string & prepend
                            )
{
   return fileNamePrependAppend(fname, prepend, "");
}
 
std::string getSequentialFilename( const std::string & basename,
                                   const std::string & extension,
                                   const int startat,
                                   const int ndigit
                                 )
{
   //int maxdig = 1;
   //for(int j=0;j<ndigit;++j) maxdig *= 10;
   int maxdig = pow(10, ndigit);
 
   char formstr[64];
   snprintf(formstr, sizeof(formstr), "%%0%dd", ndigit);
   
   char digstr[64];
   int i = startat;
 
   std::stringstream outn;
 
   snprintf(digstr,sizeof(digstr),formstr, i);
 
   outn << basename;
   outn << digstr;
   outn << extension;
 
   while(boost::filesystem::exists(outn.str()) && i < maxdig)
   {
      ++i;
      outn.str("");
 
      snprintf(digstr,sizeof(digstr), formstr, i);
 
      outn << basename;
      outn << digstr;
 
      outn << extension;
   }
 
   return outn.str();
}
 
off_t fileSize( int fd )
{
   if (fd == -1) 
   {
      return -1;
   }
 
   struct stat stbuf;
 
   if ((fstat(fd, &stbuf) != 0) || (!S_ISREG(stbuf.st_mode))) 
   {
      return -1; 
   }
  
   return stbuf.st_size;
  
}
 
off_t fileSize( FILE * f )
{
   return fileSize(fileno(f));  
}
 
 
} //namespace ioutils
} //namespace mx