---

posix.cpp

//FILE:         posix.cpp
//AUTHOR:       Nathan Cournia <nathan@cournia.com>
//DESCRIPTION:  POSIX compatable utility functions.

#include <unistd.h>
#include <sys/stat.h>
#include <vector>
#include <cerrno>
#include <cstring>
#include "utils.h"

bool
utils::mkdir( const std::string& filename )
{
        if( !(::mkdir( filename.c_str( ), 0755 ) == 0) ) {
                set_error( ::strerror( errno ) );
                return false;
        }
        clear_error( );
        return true;
}

bool
utils::exists( const std::string& filename )
{
        struct stat tmp;
        if( !(stat (filename.c_str( ), &tmp) >= 0)) {
                set_error( ::strerror( errno ) );
                return false;
        }
        clear_error( );
        return true;
}

bool
utils::can_read( const std::string& filename )
{
        if( !(access( filename.c_str( ), R_OK ) == 0) ) {
                set_error( ::strerror( errno ) );
                return false;
        }
        clear_error( );
        return true;
}

bool
utils::is_dir( const std::string& filename )
{
        struct stat tmp;
        if( lstat( filename.c_str( ), &tmp ) == 0 ) {
                if( S_ISDIR( tmp.st_mode ) ) {
                        clear_error( );
                        return true;
                }
        }
        set_error( ::strerror( errno ) );
        return false;
}

bool
utils::is_link( const std::string& filename )
{
        struct stat tmp;
        if( lstat( filename.c_str( ), &tmp ) == 0 ) {
                if( S_ISLNK( tmp.st_mode ) ) {
                        clear_error( );
                        return true;
                }
        }
        set_error( ::strerror( errno ) );
        return false;
}

bool
utils::chdir( const std::string& filename )
{
        if( !(::chdir( filename.c_str( ) ) == 0) ) {
                set_error( ::strerror( errno ) );
                return false;
        }
        clear_error( );
        return true;
}

std::string
utils::get_valid_absolute_dir( const std::string& file )
{
        //trim whitespace
        std::string filename = file;
        filename = utils::trim( utils::rtrim( filename ) );

        //make sure the string is not empty
        if( filename.length( ) < 1 ) return "";
        
        //is this file path absolute
        if( filename[ 0 ] != '/' ) {
                //relative path, get cwd
                char cwd[ 1024 ]; //hope this is enough
                getcwd( cwd, 1024 );

                //add relative path to full path
                filename = std::string( cwd ) + "/" + filename;
        }

        //create a stack
        std::vector<std::string> stack;

        //place dirs on stack
        std::string::size_type start = 0;
        std::string::size_type pos = 0;
        std::string token;

        //delimit by "/"
        while( (pos = filename.find_first_of( "/", start )) != std::string::npos ) {
                token = filename.substr( start, pos - start );
                if( token == ".." ) {
                        //go back a dir, pop the stack
                        if( stack.size( ) > 0 ) {
                                stack.pop_back( );
                        }
                } else if( (token.length( ) > 0) && (token != ".") ) {
                        //place token on stack
                        stack.push_back( token );
                }

                //move current string position
                start = pos + 1;
        }

        //there still may be a dir at the end
        if( start < filename.length( ) ) {
                token = filename.substr( start, filename.length( ) - start );
                if( token == ".." ) {
                        //go back a dir, pop the stack
                        if( stack.size( ) > 0 ) {
                                stack.pop_back( );
                        }
                } else if( (token.length( ) > 0) && (token != ".") ) {
                        //place token on stack
                        stack.push_back( token );
                }
        }

        //if the stack size is greater than one, see if the dir
        filename = "";
        if( stack.size( ) > 1 ) {
                std::string old;
                for( unsigned int i = 0; i < stack.size( ); ++i ) {
                        old = filename;
                        filename += "/" + stack[ i ];
                        if( !(utils::is_dir( filename.c_str( ) )) ) {
                                //not a dir, go back to old as the last valid dir
                                if( old.length( ) < 1 ) {
                                        return "/";
                                } else {
                                        return old;
                                }
                        }
                }
                
                //the whole string was a dir
                return filename;
        } else if( stack.size( ) == 1 ) {
                //looks like the file looks like /filename
                filename += "/" + stack[ 0 ];
                if( utils::is_dir( filename.c_str( ) ) ) {
                        return filename;
                } else {
                        return "/";
                }
        } else {
                //fuck, this shouldn't happen
                return "";
        }
}

std::string
utils::get_absolute_dir( const std::string& file )
{
        //trim whitespace
        std::string filename = file;
        filename = utils::trim( utils::rtrim( filename ) );

        //make sure the string is not empty
        if( filename.length( ) < 1 ) return "";
        
        //is this file path absolute
        if( filename[ 0 ] != '/' ) {
                //relative path, get cwd
                char cwd[ 1024 ]; //hope this is enough
                getcwd( cwd, 1024 );

                //add relative path to full path
                filename = std::string( cwd ) + "/" +  filename;
        }

        //create a stack
        std::vector<std::string> stack;

        //place dirs on stack
        std::string::size_type start = 0;
        std::string::size_type pos = 0;
        std::string token;

        //delimit by "/"
        while( (pos = filename.find_first_of( "/", start )) != std::string::npos ) {
                token = filename.substr( start, pos - start );
                if( token == ".." ) {
                        //go back a dir, pop the stack
                        if( stack.size( ) > 0 ) {
                                stack.pop_back( );
                        }
                } else if( (token.length( ) > 0) && (token != ".") ) {
                        //place token on stack
                        stack.push_back( token );
                }

                //move current string position
                start = pos + 1;
        }

        //there still may be a dir at the end
        if( start < filename.length( ) ) {
                token = filename.substr( start, filename.length( ) - start );
                if( token == ".." ) {
                        //go back a dir, pop the stack
                        if( stack.size( ) > 0 ) {
                                stack.pop_back( );
                        }
                } else if( (token.length( ) > 0) && (token != ".") ) {
                        //place token on stack
                        stack.push_back( token );
                }
        }

        filename = "";
        if( stack.size( ) > 1 ) {
                for( unsigned int i = 0; i < stack.size( ) - 1; ++i ) {
                        filename += "/" + stack[ i ];
                }
                return filename;
        } else {
                return "/";
        }
}

std::string
utils::get_filename( const std::string& file )
{
        std::string::size_type pos = file.find_last_of( "/", file.length( ) );
        if( pos == std::string::npos ) {
                //no slashes
                return file;
        } else {
                return file.substr( pos + 1, file.length( ) - (pos + 1) );
        }
}

---