FileFunctions.cpp File Reference

implements of file system function. More...

#include "stdafx.h"
#include "FileFunctions.h"
#include "LogFunctions.h"
#include "StringFunctions.h"
#include "CoreMacros.h"
#include "ErrorCode.h"
#include <vector>
#include <list>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/bind.hpp>
#include <direct.h>

Include dependency graph for FileFunctions.cpp:

Go to the source code of this file.

Functions
bool	fileexists (const char *path)
	judge whether file exists More...
bool	isdirectory (const char *path)
	judge whether file is directory More...
bool	checkfile (const char *path)
	check file before open. (This function calls fileexists and isdirectory ) More...
std::string	getfilename (const char *path)
	get file name More...
std::string	getdir (const char *path)
	get dir that the file exists More...
std::string	getpath (const char *dir, const char *file)
	get file path More...
std::string	absolutepath (const char *path)
	get absolute path More...
std::string	getabsolutepath (const char *dir, const char *file)
	get absolute path More...
bool	isabsolutepath (const char *file)
	judges whether the specified file path is absolute file path or not. More...
void	setarguments (int argc, char **argv)
	set arguments More...
int	getargc ()
	get number of arguments More...
const char *	getargv (int index)
	get argument More...
std::string	getext (const char *path)
	get the extension of the file More...
std::string	getenvariable (const char *name)
	get environment variable More...
std::string	getmodulefile ()
	gets module file path More...
std::string	getmoduledir ()
	gets module file directory More...
std::string	gethomedir ()
	gets current user's home directory More...
FILE *	fileopen (const char *path, const char *mode)
	opens file More...
void	fileseek (FILE *fp, long long offset, int origin)
	sets file position More...
long long	filetell (FILE *fp)
	gets file position More...
bool	copyfile (const char *src, const char *dst)
	copies file More...
bool	removefile (const char *path)
	removes file More...
bool	makedirectory (const char *path)
	creates directory More...
bool	removedirs (const char *path)
	remove directories More...
bool	makedirs (const char *path)
	make directories More...
std::string	getplugindir ()
	gets mspp plugin paths
unsigned long long	filesize (const char *path)
	gets the file size More...
std::string	searchfile (const char *dir, const char *fileName, const bool recursive)
	searches file More...

Variables
std::vector< std::string >	g_arguments
std::string	g_moduleFile
std::string	g_homeDir

Detailed Description

implements of file system function.

Author

S.Tanaka

Date

2006.06.28

Copyright(C) 2006-2014 Eisai Co., Ltd. All rights reserved.

Definition in file FileFunctions.cpp.

Function Documentation

std::string absolutepath

(

const char *

path

)

get absolute path

Parameters

[in]

path

file path

Returns

absolute path

Definition at line 176 of file FileFunctions.cpp.

                                           {
    // check parameter
    if( path == NULL ) {
        return "";
    }

    // create path object
    boost::filesystem::path p( path, boost::filesystem::native );

    // get absolute path
    boost::filesystem::path absPath = boost::filesystem::absolute( p );

    return absPath.string();
}

bool checkfile

(

const char *

path

)

check file before open. (This function calls fileexists and isdirectory )

Parameters

[in]

path

file path

Returns

true: The path specified exists and is not directory.

Definition at line 92 of file FileFunctions.cpp.

                                   {
    // check parameter
    if( path == NULL ) {
        LOG_ERROR( FMT( "The file path is null." ) );
        return false;
    }

    //
    if( !fileexists( path ) ) {
        LOG_ERROR_CODE( FMT( "The file does not exist. [%s]", path ), ERR_FILE_NOT_FOUND );
        return false;
    }

    if( isdirectory( path ) ){
        LOG_ERROR_CODE( FMT( "The path is a directory. A file should be specified. [%s]", path ), ERR_PATH_IS_DIRECTORY );
        return false;
    }

    return true;
}

Here is the call graph for this function:

bool copyfile	(	const char *	src,
		const char *	dst
	)

copies file

Parameters

[in]	src	file path to be copied
[in]	dst	copy file path

Returns

If true, it succeeded to copy a file.

Definition at line 438 of file FileFunctions.cpp.

                                                  {
    // buffer
    char buff[ 0x10000 ];

    // file open
    FILE* srcFp = fileopen( src, "rb" );
    if( srcFp == NULL ) {
        return false;
    }

    FILE* dstFp = fileopen( dst, "wb" );
    if( dstFp == NULL ) {
        return false;
    }

    // copy
    size_t len = int();
    while( ( len = fread( buff, 1, 0x10000, srcFp ) ) > 0 ) {
        fwrite( buff, 1, len, dstFp );
    }

    // close
    fflush( dstFp );
    fclose( dstFp );
    fclose( srcFp );

    return true;
}

Here is the call graph for this function:

bool fileexists

(

const char *

path

)

judge whether file exists

Parameters

[in]

path

file path

Returns

true: file exists. | false: file doesn't exist

Definition at line 51 of file FileFunctions.cpp.

                                    {
    // check parameter
    if( path == NULL ) {
        return false;
    }

    // create path object
    boost::filesystem::path p( path, boost::filesystem::native );

    // judge
    bool ret = false;
    try{
        ret = boost::filesystem::exists( p );
    }
    catch( ... ) {
        ret = false;
    }

    return ret;
}

FILE * fileopen	(	const char *	path,
		const char *	mode
	)

opens file

Parameters

[in]	path	file path to be opened
[in]	mode	open mode

Returns

file descriptor

Definition at line 399 of file FileFunctions.cpp.

                                                     {
    // file descriptor
    FILE* fp = NULL;

#ifdef _MSC_VER
    errno_t ret = fopen_s( &fp, path, mode );
    if( ret != 0 ) {
        fp = NULL;
    }
#else
    fp = fopen( path, mode );
#endif  // MSC_VER

    return fp;
}

void fileseek	(	FILE *	fp,
		long long	offset,
		int	origin
	)

sets file position

Parameters

[in]	fp	file descriptor
[in]	offset	position from origin
[in]	origin	SEEK_SET, SEEK_CUR or SEEK_END (see "fseek" document)

Definition at line 416 of file FileFunctions.cpp.

                                                        {

#ifdef _MSC_VER
    _fseeki64( fp, offset, origin );
#else
    fseeko64( fp, offset, origin );
#endif
}

unsigned long long filesize

(

const char *

path

)

gets the file size

Parameters

[in]

path

file path

Returns

file size

Definition at line 576 of file FileFunctions.cpp.

                                                {
    // path object
    boost::filesystem::path p( path, boost::filesystem::native );

    // size
    unsigned long long size = (unsigned long long)boost::filesystem::file_size( p );

    return size;
}

long long filetell

(

FILE *

fp

)

gets file position

Parameters

[in]

fp

file description

Returns

the file position

Definition at line 426 of file FileFunctions.cpp.

                               {
    long long pos = 0;
#ifdef _MSC_VER
    pos = _ftelli64( fp );
#else
    pos = ftello64( fp );
#endif

    return pos;
}

std::string getabsolutepath	(	const char *	dir,
		const char *	file
	)

get absolute path

• If dir has root, this function returns getpath( dir, file )
• If dir doesn't have root, this function returns absolutepath( getpath( dir, file ) );

  Parameters

  [in]	dir	directory name
  [in]	file	file name

  Returns

  file path

Definition at line 192 of file FileFunctions.cpp.

                                                               {
    // create path object
    boost::filesystem::path p( getpath( dir, file ), boost::filesystem::native );
    p.normalize();
    std::string ret = p.string();
    ret = replacestring( ret.c_str(), "/", DIR_SEPARATOR );

    // return path
    if( p.is_complete() ) { // dir has root
        return ret;
    }

    return absolutepath( ret.c_str() );
}

Here is the call graph for this function:

int getargc

(

)

get number of arguments

Returns

number of arguments

Definition at line 232 of file FileFunctions.cpp.

              {
    // check variable
    if( g_arguments.size() <= 0 ) {
        LOG_WARN( FMT( "\"setarguments\" function has not been called yet." ) );
    }

    return (int)g_arguments.size();
}

const char * getargv

(

int

index

)

get argument

Parameters

[in]

index

argument index

Returns

argument ( if index < 0 or index > 0 returns NULL )

Definition at line 242 of file FileFunctions.cpp.

                                 {
    // check variable
    if( g_arguments.size() <= 0 ) {
        LOG_WARN( FMT( "\"setarguments\" function has not been called yet." ) );
    }

    // check index
    if( index < 0 || index >= (int)g_arguments.size() ) {
        return NULL;
    }

    return g_arguments[index].c_str();
}

std::string getdir

(

const char *

path

)

get dir that the file exists

Parameters

[in]

path

file path

Returns

directory part

Definition at line 129 of file FileFunctions.cpp.

                                     {
    // check parameter
    if( path == NULL ) {
        return "";
    }

    // create path object
    boost::filesystem::path p( path, boost::filesystem::native );

    // directory
    if( p.has_branch_path() ) {
        p = p.branch_path();
        return p.string();
    }

    return std::string( "" );
}

std::string getenvariable

(

const char *

name

)

get environment variable

Parameters

[in]

name

environment variable name

Returns

environment vaiable value

Definition at line 274 of file FileFunctions.cpp.

                                            {
    // check parameter
    if( name == NULL ) {
        return std::string( "" );
    }

    // get environment variable
    std::string value;

#ifdef _MSC_VER
    size_t size = 0;
    char* v = NULL;
    _dupenv_s( &v, &size, name );
    if( v != NULL ) {
        value = std::string( v );
        delete[] v;
    }
#else
    char* v = getenv( name );
    if( v != NULL ) {
        value = std::string( v );
    }

#endif  // _MSC_VER

    return value;
}

std::string getext

(

const char *

path

)

get the extension of the file

Parameters

[in]

path

file path

Returns

the extension of the file

Definition at line 257 of file FileFunctions.cpp.

                                     {
    // check parameter
    if( path == NULL ) {
        return std::string( "" );
    }

    // find '.'
    std::string p( path );
    size_t pos = p.find_last_of( "." );
    if( pos == p.npos ) {
        return "";
    }
    
    return p.substr( pos + 1 );
}

std::string getfilename

(

const char *

path

)

get file name

Parameters

[in]

path

file path

Returns

file name (excluding directory part)

Definition at line 114 of file FileFunctions.cpp.

                                          {
    // check parameter
    if( path == NULL ) {
        return "";
    }

    // create path object
    boost::filesystem::path p( path, boost::filesystem::native );

    // leaf
    std::string name = p.leaf().string();
    return name;
}

std::string gethomedir

(

)

gets current user's home directory

Returns

current user's home directory

Definition at line 374 of file FileFunctions.cpp.

                       {
    // check global variable
    if( !g_homeDir.empty() ) {
        return g_homeDir;
    }

    // get home dir
    std::string homeDir;

#ifdef __unix
    homeDir = getenvariable( "HOME" );
    if( homeDir.empty() ) {     
        homeDir = "~";
    }
#else
    std::string homeDrive = getenvariable( "HOMEDRIVE" );
    std::string homePath = getenvariable( "HOMEPATH" );
    homeDir = homeDrive + homePath;
#endif  // __unix
    g_homeDir = absolutepath( homeDir.c_str() );
    
    return g_homeDir;
}

Here is the call graph for this function:

std::string getmoduledir

(

)

gets module file directory

Returns

module file directory

Definition at line 369 of file FileFunctions.cpp.

                         {
    return getdir( getmodulefile().c_str() );
}

Here is the call graph for this function:

std::string getmodulefile

(

)

gets module file path

Returns

module file path

Definition at line 303 of file FileFunctions.cpp.

                          {
    // check global variables
    if( !g_moduleFile.empty() ) {
        return g_moduleFile;
    }
    if( g_arguments.size() <= 0 ) {
        LOG_WARN( FMT( "\"setarguments\" function has not been called yet." ) );
        return std::string( "" );
    }

    // get file name
    std::string program = getfilename( g_arguments[0].c_str() );
    std::string fileName = program;

#ifndef __unix      // Windows

    std::string ext = getext( fileName.c_str() );
    if( compareignorecase( ext.c_str(), "exe" ) != 0 ) {
        fileName.append( ".exe" );
    }

#endif  // __unix

    if( strcmp( program.c_str(), g_arguments[0].c_str() ) == 0 ) {  // search PATH
        // get environment variable "PATH"
#ifdef __unix       // unix
        std::string p = getenvariable( "PATH" );
#else       // windows
        std::string p = getenvariable( "Path" );
#endif      // __unix

        // creating search path list
        std::vector<std::string> paths; 
        stringtoken(
            p.c_str(),
            PATH_SEPARATOR, 
                paths
        );

#ifndef __unix      // Windows
        paths.insert(paths.begin(), std::string("."));
#endif  // __unix

        // search path
        for( unsigned int xx = 0; g_moduleFile.empty() && xx < paths.size(); xx++) {

            if( !paths[xx].empty() ) {
                try {
                    std::string pgPath = getabsolutepath( paths[xx].c_str(), fileName.c_str() );
                    if( fileexists( pgPath.c_str() ) ) {
                                g_moduleFile = pgPath;
                    }
                }
                catch( ... ) {
                }
            }
        }
    }
    else {  // specified directory
        g_moduleFile = getabsolutepath( getdir( g_arguments[0].c_str() ).c_str(), fileName.c_str() );
    }

    return g_moduleFile;
}

Here is the call graph for this function:

std::string getpath	(	const char *	dir,
		const char *	file
	)

get file path

Parameters

	dir	directory name
[in]	file	file name

Returns

file path

Definition at line 148 of file FileFunctions.cpp.

                                                       {
    // check parameter
    if( dir == NULL && file == NULL ) {
        return std::string( "" );
    }
    if( dir == NULL ) {
        return std::string( file );
    }
    if( file == NULL ) {
        return std::string( dir );
    }

    // create path object
    boost::filesystem::path filePath( file, boost::filesystem::native );

    std::string mergeFileName = FMT( "%s%s%s", dir, DIR_SEPARATOR, file );
    boost::filesystem::path mergePath( mergeFileName.c_str(), boost::filesystem::native );

    // return path
    boost::filesystem::path p = filePath.is_complete() ? filePath : mergePath;      
    p.normalize();
    std::string ret = p.string();
    ret = replacestring( ret.c_str(), "/", DIR_SEPARATOR );
    ret = replacestring( ret.c_str(), "\\", DIR_SEPARATOR );
    return ret;
}

Here is the call graph for this function:

bool isabsolutepath

(

const char *

file

)

judges whether the specified file path is absolute file path or not.

Parameters

[in]

file

file path

Returns

If true, the specified file path is absolute file path.

Definition at line 208 of file FileFunctions.cpp.

                                        {
    // create path object
    boost::filesystem::path p( file, boost::filesystem::native );
    p.normalize();

    // judge
    return p.is_complete();
}

bool isdirectory

(

const char *

path

)

judge whether file is directory

Parameters

[in]

path

file path

Returns

true: path is directory. | false: path is not directory.

Definition at line 73 of file FileFunctions.cpp.

                                     {
    // check parameter
    if( !fileexists( path ) ) {
        return false;
    }

    // create path object
    boost::filesystem::path p( path, boost::filesystem::native );

    // check existing
    if( !boost::filesystem::exists( p ) ) {
        return false;
    }

    // judgement
    return boost::filesystem::is_directory( p );
}

Here is the call graph for this function:

bool makedirectory

(

const char *

path

)

creates directory

Parameters

[in]

path

directory path to be maken

Returns

If true, it succeeded to make a directory.

Definition at line 486 of file FileFunctions.cpp.

                                       {
    // result
    int ret = 0;

#ifdef  _MSC_VER
    ret = _mkdir( path );
#else
    ret = mkdir( path, 0755 );
#endif

    if( ret != 0 ) {
        LOG_ERROR( FMT( "Failed to create the directory. [%s]", NVL( path, "" ) ) );
    }

    return ( ret == 0 );
}

bool makedirs

(

const char *

path

)

make directories

Parameters

[in]

path

directory path

Definition at line 541 of file FileFunctions.cpp.

                                  {
    // path object
    boost::filesystem::path p( path, boost::filesystem::native );
    p = boost::filesystem::absolute( p );

    // check
    if( boost::filesystem::exists( p ) ) {
        return false;
    }

    // branch
    bool ret = true;
    boost::filesystem::path branche = p.branch_path();
    if( !boost::filesystem::exists( branche ) ) {
        if( !makedirs( branche.string().c_str() ) ) {
            ret = false;
        }       
    }

    // make directory
    if( ret ) {
        ret = makedirectory( p.string().c_str() );
    }

    return ret;
}

Here is the call graph for this function:

bool removedirs

(

const char *

path

)

remove directories

Parameters

[in]

path

directory path

Definition at line 504 of file FileFunctions.cpp.

                                    {
    // path object
    boost::filesystem::path p( path, boost::filesystem::native );
    boost::filesystem::directory_iterator end;

    // check
    if( !boost::filesystem::exists( p ) ) {
        LOG_WARN( FMT( "%s does not exist.", path ) );
        return false;
    }

    // remove
    bool ret = true;
    if( boost::filesystem::is_directory( p ) ) {    // directory
        for( boost::filesystem::directory_iterator it( p ); it != end; it++ ) {
            boost::filesystem::path child = boost::filesystem::absolute( *it );
            if( !removedirs( child.string().c_str() ) ) {
                ret = false;
            }
        }

#ifdef _MSC_VER
        _rmdir( path );
#else
        rmdir( path );
#endif
    }
    else {  // file
        if( !removefile( path ) ) {
            ret = false;
        }
    }

    return ret;
}

Here is the call graph for this function:

void removefile

(

const char *

path

)

removes file

Parameters

[in]

path

file path to be removed

Returns

If true, it succeeded to remove a file.

Definition at line 468 of file FileFunctions.cpp.

                                    {
    // result
    int ret = 0;

#ifdef _MSC_VER
    ret = _unlink( path );
#else
    ret = unlink( path );
#endif

    if( ret != 0 ) {
        LOG_ERROR( FMT( "Failed to remove the file. [%s]", NVL( path, "" ) ) );
    }

    return ( ret == 0 );
}

std::string searchfile	(	const char *	dir,
		const char *	fileName,
		const bool	recursive
	)

searches file

Parameters

[in]	dir	file directory
[in]	fileName	file name
[in]	recursive	If true, search file recursively.

Returns

If the file is found, this function returns file path. Otherwise, empty string.

Definition at line 587 of file FileFunctions.cpp.

                                                                                    {
    // return value
    std::string filePath;

    // search files
    std::vector< std::string > dirs;

    boost::filesystem::path p( dir, boost::filesystem::native );
    if( !boost::filesystem::exists( p ) ) {
        return filePath;
    }

    boost::filesystem::directory_iterator end;
    for( boost::filesystem::directory_iterator it( p ); it != end && filePath.empty(); it++ ) {
        std::string childName = (*it).path().leaf().string();
        std::string child = getpath( dir, (*it).path().leaf().string().c_str() );

        if( childName.compare( fileName ) == 0 ) {
            filePath = child;
        }
        else if( isdirectory( child.c_str() ) ) {
            dirs.push_back( child );
        }
    }

    // search folders
    if( recursive ) {
        for( unsigned int i = 0; i < dirs.size() && filePath.empty(); i++ ) {
            filePath = searchfile( dirs[ i ].c_str(), fileName, true );
        }
    }

    return filePath;

}

Here is the call graph for this function:

void setarguments	(	int	argc,
		char **	argv
	)

set arguments

Parameters

[in]	argc	the number of arguments
[in]	argv	the array of arguments

Definition at line 218 of file FileFunctions.cpp.

                                           {
    // initialize the array
    g_arguments.clear();

    // keep arguments
    if( argc > 0 ){
        g_arguments.reserve( argc );
    }
    for( int i = 0; i < argc; i++ ){
        g_arguments.push_back( std::string( argv[i] ) );
    }
}

Variable Documentation

std::vector<std::string> g_arguments

the array of arguments

Definition at line 41 of file FileFunctions.cpp.

std::string g_homeDir

home directory

Definition at line 47 of file FileFunctions.cpp.

std::string g_moduleFile

module file path

Definition at line 44 of file FileFunctions.cpp.