utilities/directory_utilities.cpp

Go to the documentation of this file.

#ifndef         __DIRECTORY_UTILITIES_CPP__
#define         __DIRECTORY_UTILITIES_CPP__

#include        <utilities/directory_utilities.h>
#include        <utilities/exception.h>
#include        <utilities/string_utilities.h>

namespace nitro
{
        /* static */ void                                               Directory::ForceCreateDirectory( const char * DirPath )
        {
                try
                {
                        char                    * SafePath;
                        SafePath = new char[ strlen( DirPath ) + 1 ];
                        // обрубаем концевой слэш если нужно
                        nitro::FSPath::DeleteEndSlash( DirPath , SafePath );

                        // произошла ошибка
                        // проверяем может быть директория создана раньше
                        if( DirectoryExists( ( const char * )SafePath ) )
                        {
                                // т.е. такая директория уже создана
                                // кстати тут обрабатывается такая ситуация - когда в функцию передан <drive_letter>:/
                                // тогда DirectoryExists вернет true для <drive_letter>:, т.к. она автоматом прибавляет / к пути
                                return;
                        }

                        // директория не была создана раньше следовательно идем выше по пути
                        char                    SubSafePath[ 4096 ];
                        if( std::string( nitro::FSPath::ExtractFilePath( SafePath , SubSafePath ) ) == SafePath )
                        {
                                // т.е. не удалось выделить имя файла
                                throw( nitro::exception( std::string( "An error occured while extracting file path from " ) + SafePath , 0 ) );
                        }
                        else
                        {
                                ForceCreateDirectory( ( const char * )SubSafePath );

                                DirectoryAbstraction::CreateDirectory( ( const char * )SafePath );

                                //директория создана
                        }

                        delete [] SafePath;
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "/* static */ void Directory::ForceCreateDirectory( const char * DirPath )::" ) + e.what() , e.code() ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "/* static */ void Directory::ForceCreateDirectory( const char * DirPath )::An error occured" ) , 0 ) );
                }
        }

        /* static */ void                                               Directory::ForceCreateDirectory( const std::string & DirPath )
        {
                try
                {
                        ForceCreateDirectory( DirPath.c_str() );
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Directory::ForceCreateDirectory( const std::string & DirPath )::" ) + e.what() , e.code() ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Directory::ForceCreateDirectory( const std::string & DirPath )::An error occured" ) , 0 ) );
                }
        }

        /* static */ bool                                               Directory::DirectoryExists( const char * DirPath )
        {
                try
                {
                        nitro::DirectoryAbstraction             Directory;
                        std::string                             TmpDirectoryPath( nitro::FSPath::AddEndSlash( std::string( DirPath ) ) );

                        if( Directory.FindFirst( TmpDirectoryPath.c_str() ) )
                        {
                                return( false );
                        }

                        return( true );
                }
                catch( nitro::exception e )
                {
                        return( false );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "bool Directory::DirectoryExists( const char * DirPath )::An error occured" ) , 0 ) );
                }
        }

        /* static */ bool                                               Directory::DirectoryExists( const std::string & DirPath )
        {
                try
                {
                        return( DirectoryExists( DirPath.c_str() ) );
                }
                catch( nitro::exception e )
                {
                        throw( nitro::exception( std::string( "Directory::DirectoryExists( const std::string & DirPath )::" ) + e.what() , e.code() ) );
                }
                catch( ... )
                {
                        throw( nitro::exception( std::string( "Directory::DirectoryExists( const std::string & DirPath )::An error occured" ) , 0 ) );
                }
        }

        Directory::~Directory()
        {
                try
                {
                }
                catch( ... )
                {
                }
        }

        // \~russian секция автотестирования
        // \~english unit tests

        BEGIN_TESTING_SECTION()

                ENABLE_CLASS_TESTING( Directory )

                FUNCTION_TESTING_1( aliasDirectoryExists , tstDirectoryExists , const char * , bool , bool )
                FUNCTION_TESTING_1( aliasForceCreateDirectory , tstForceCreateDirectory , const char * , void , NO_RET )

        END_TESTING_SECTION()
}

#endif