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 <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include <filesystem>
 
namespace mx
{
namespace ioutils
{
 
namespace fileUtilsDetail
{
 
namespace
{
 
void noOperationFailure( operation )
{
}
 
void noErrorCodeFailure( operation, std::error_code & )
{
}
 
} // namespace
 
operationHookT &operationHook()
{
    static operationHookT hook = noOperationFailure;
    return hook;
}
 
errorCodeHookT &errorCodeHook()
{
    static errorCodeHookT hook = noErrorCodeFailure;
    return hook;
}
 
} // namespace fileUtilsDetail
 
template bool exists<verbose::d>( const std::string &, error_t & );
 
template bool dir_exists_is<verbose::d>( const std::string &, error_t & );
 
error_t createDirectories( const std::string &path )
{
    // Use the non throwing version and silently ignore EEXIST errors
    std::error_code ec;
    std::filesystem::create_directories( path, ec );
    fileUtilsDetail::errorCodeHook()( fileUtilsDetail::operation::createDirectories, ec );
    if( ec.value() != 0 && ec.value() != EEXIST )
    {
        mx::error_t errc = errno2error_t( ec.value() );
        if( errc == error_t::error )
        {
            errc = error_t::filesystem;
        }
        return errc;
    }
 
    return error_t::noerror;
}
 
std::string pathStem( const std::string &fname )
{
    std::filesystem::path p( fname );
    return p.stem().string();
}
 
std::string pathFilename( const std::string &fname )
{
    std::filesystem::path p( fname );
    return p.filename().string();
}
 
std::string parentPath( const std::string &fname )
{
    std::filesystem::path p( fname );
    return p.parent_path().string();
}
 
template error_t getFileNames<verbose::d>( std::vector<std::string> &fileNames,
                                           const std::string &directory,
                                           const std::string &prefix,
                                           const std::string &substr,
                                           const std::string &extension );
 
std::string fileNamePrependAppend( const std::string &fname, const std::string &prepend, const std::string &append )
{
    std::string dir, base, ext;
 
    std::filesystem::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( std::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