UTPath.h

Go to the documentation of this file.

//==================================================================================================
// Copyright (C) 2010  Brian Tietz    sdbtietz at yahoo dot com
//
// This program 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, version 2.0 of the
// License.
//
// This program 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 this program; if
// not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
// For commercial software, the copyright holder (Brian Tietz, email sdbtietz at yahoo dot com)
// reserves the right and is willing to waive the proprietary source code disclosure aspects of that
// license as applied to the UT library in exchange for either substantial contributions to the
// development of the UT library or other forms of compensation.  Any such waiver must be
// established in writing between the copyright holder and the commercial entity obtaining such a
// waiver.
//==================================================================================================


#ifndef _UT_PATH_H_
#define _UT_PATH_H_


//==================================================================================================
//=== System headers
//==================================================================================================
#include <limits.h>
#include <fcntl.h>


//==================================================================================================
//=== Project headers
//==================================================================================================
#include "UTString.h"


//==================================================================================================
//=== Forward name declarations
//==================================================================================================
class PathNode_t;


//==================================================================================================
class UT_EXPORT Path_t
//==================================================================================================
: public String_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                      Path_t();

    inline                      Path_t( byte* buffer, int buffer_size );

    inline                      Path_t(stringliteral* path);

    inline                      Path_t(const utf8* path);

    inline                      Path_t(const Path_t& path);

    inline                      Path_t(const String_t& path);

    // Checked set functions
    inline Status_t             Set(stringliteral* path);

    inline Status_t             Set(const utf8* path);

    inline Status_t             Set(const Path_t& path);

    inline Status_t             Set(const String_t& path);

    // Unchecked set operator s
    inline const Path_t&        operator =(stringliteral* path);

    inline const Path_t&        operator =(const utf8* path);

    inline const Path_t&        operator =(const Path_t& path);

    inline const Path_t&        operator =(const String_t& path);

    bool                        IsPathValid() const;

    // Checked append functions
    inline Status_t             Append(stringliteral* leaf);

    Status_t                    Append(const utf8* leaf);

    inline Status_t             Append(const Path_t& leaf);

    inline Status_t             Append(const String_t& leaf);

    inline Status_t             AppendToLeaf(stringliteral* add_to_leaf);

    inline Status_t             AppendToLeaf(const utf8* add_to_leaf);

    inline Status_t             AppendToLeaf(const String_t& add_to_leaf);

    // Unchecked append operator s
    inline const Path_t&        operator +=(stringliteral* path);

    inline const Path_t&        operator +=(const utf8* path);

    inline const Path_t&        operator +=(const Path_t& leaf);

    inline const Path_t&        operator +=(const String_t& leaf);

    inline Path_t               operator +(stringliteral* append) const;

    inline Path_t               operator +(const utf8* append) const;

    inline Path_t               operator +(const Path_t& append) const;

    inline Path_t               operator +(const String_t& append) const;

    Status_t                    GetLeafName(out Path_t* leaf) const;

    Status_t                    ToRelative( const Path_t& relative_to, bool canonical = true );

    Status_t                    ToParent();

    inline Status_t             GetParent(out Path_t* parent) const;

    Status_t                    IsDirectory() const;

    Status_t                    GetDirectory(out Path_t* dir) const;

    Status_t                    IsAbsolute() const;

    Status_t                    MakeAbsolute();

    Status_t                    IsRootDirectory() const;

    Status_t                    IsRegularFile() const;

    Status_t                    RegularFileSize(out fileoff_t* size) const;

    Status_t                    IsSymLink() const;

    Status_t                    MakeDir(    bool recursive = true,
                                            mode_t permissions = S_IRWUSR | S_IXUSR) const;

    Status_t                    Delete(bool recursive = false) const;

    static Status_t             GetAppPath(out Path_t* app_path);

    static Status_t             GetAppDir(out Path_t* app_dir);

    static Status_t             GetCurrentWorkingDir(out Path_t* cwd);

    static Status_t             SetCurrentWorkingDir(const Path_t& cwd);

    static Status_t             GetHomeDir(out Path_t* home);

    inline static bool          IsDelimiter(utf8 c);

    inline Status_t             StripCurrAndParentDirs();

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    static Status_t             BadPathError( stringliteral* format, const utf8* path_name );
                                    // Creates a bad path error status with explanatory text
                                    // attached to the returned Status_t.  The explanatory text will
                                    // be constructed using String_t::Printf( format, path_name ) so
                                    // format should be a printf-style format string with %s where
                                    // the path_name should be inserted.

    static Status_t             BadPathError(const utf8* path_name);
                                    // Creates a bad path error status with explanatory text
                                    // attached to the returned Status_t to indicate the path and
                                    // that it was invalid.

    static Status_t             PathNotFoundError( stringliteral* format, const utf8* path_name );
                                    // Creates a path not found error status with explanatory text
                                    // attached to the returned Status_t.  The explanatory text will
                                    // be constructed using String_t::Printf( format, path_name ) so
                                    // format should be a printf-style format string with %s where
                                    // the path_name should be inserted.

    static Status_t             PathNotFoundError(const utf8* explanation);
                                    // Creates a path not found error status with explanatory text
                                    // attached to the returned Status_t to indicate the path and
                                    // that it was not found.

    static bool                 InitAndCheckAllNodes( out PathNode_t* node, const utf8* path );
                                    // Caller provides an uninitialized PathNode_t.  If
                                    // CheckAllNodes returns true, all nodes are good and the node
                                    // parameter will reference the last node in the path.

    bool                        StripCurrAndParentDirsInternal(bool is_absolute);
                                    // Strips current (".") and parent ("Parent/..") elements from
                                    // the path.  Returns true if successful.
};


//==================================================================================================
class UT_EXPORT PathB_t
//==================================================================================================
: public Path_t
{
    //----------------------------------------------------------------------------------------------
    public:
    //----------------------------------------------------------------------------------------------
    inline                      PathB_t();

    inline                      PathB_t(stringliteral* path);

    inline                      PathB_t(const utf8* path);

    inline                      PathB_t(const Path_t& path);

    inline                      PathB_t(const String_t& path);

    inline const Path_t&        operator =(stringliteral* path);

    inline const Path_t&        operator =(const utf8* path);

    inline const Path_t&        operator =(const Path_t& path);

    inline const Path_t&        operator =(const String_t& path);

    //----------------------------------------------------------------------------------------------
    private:
    //----------------------------------------------------------------------------------------------
    byte                        m_buffer[PATH_MAX];
};




//==================================================================================================
//==================================================================================================
//===
//=== Inline function implementations
//===
//==================================================================================================
//==================================================================================================
inline
Path_t::Path_t()
{ }


inline
Path_t::Path_t( byte* buffer, int buffer_size )
: String_t( buffer, buffer_size )
{ }


inline
Path_t::Path_t(stringliteral* path)
: String_t(path)
{ }


inline
Path_t::Path_t(const utf8* path)
: String_t(path)
{ }


inline
Path_t::Path_t(const Path_t& path)
: String_t(path)
{ }


inline
Path_t::Path_t(const String_t& path)
: String_t(path)
{ }


inline Status_t
Path_t::Set(stringliteral* path)
{
    String_t::Set(path);
    if( IsPathValid() )
        return true;
    return BadPathError( reinterpret_cast<const utf8*>(path) );
}


inline Status_t
Path_t::Set(const utf8* path)
{
    String_t::Set(path);
    if( IsPathValid() )
        return true;
    return BadPathError(path);
}


inline Status_t
Path_t::Set(const Path_t& path)
{
    String_t::Set(path);
    if( IsPathValid() )
        return true;
    return BadPathError(path);
}


inline Status_t
Path_t::Set(const String_t& path)
{
    String_t::Set(path);
    if( IsPathValid() )
        return true;
    return BadPathError(path);
}


inline const Path_t&
Path_t::operator =(stringliteral* path)
{
    String_t::Set(path);
    return *this;
}


inline const Path_t&
Path_t::operator =(const utf8* path)
{
    String_t::Set(path);
    return *this;
}


inline const Path_t&
Path_t::operator =(const Path_t& path)
{
    String_t::Set(path);
    return *this;
}


inline const Path_t&
Path_t::operator =(const String_t& path)
{
    String_t::Set(path);
    return *this;
}


inline Status_t
Path_t::Append(stringliteral* leaf)
{
    return Append( reinterpret_cast<const utf8*>(leaf) );
}


inline Status_t
Path_t::Append(const Path_t& leaf)
{
    return Append( leaf.UTF8() );
}


inline Status_t
Path_t::Append(const String_t& leaf)
{
    return Append( leaf.UTF8() );
}


inline Status_t
Path_t::AppendToLeaf(stringliteral* add_to_leaf)
{
    error_code_t error = String_t::Append(add_to_leaf).StatusCode();
    if(error < 0)
        return error;
    if( IsPathValid() )
        return true;
    return BadPathError( UTF8() );  
}


inline Status_t
Path_t::AppendToLeaf(const utf8* add_to_leaf)
{
    error_code_t error = String_t::Append(add_to_leaf).StatusCode();
    if(error < 0)
        return error;
    if( IsPathValid() )
        return true;
    return BadPathError( UTF8() );  
}


inline Status_t
Path_t::AppendToLeaf(const String_t& add_to_leaf)
{
    String_t::Append(add_to_leaf);
    if( IsPathValid() )
        return true;
    return BadPathError( UTF8() );  
}


inline const Path_t&
Path_t::operator +=(stringliteral* leaf)
{
    Append(leaf);
    return *this;
}


inline const Path_t&
Path_t::operator +=(const utf8* leaf)
{
    Append(leaf);
    return *this;
}


inline const Path_t&
Path_t::operator +=(const Path_t& leaf)
{
    Append(leaf);
    return *this;
}


inline const Path_t&
Path_t::operator +=(const String_t& leaf)
{
    Append(leaf);
    return *this;
}


inline Path_t
Path_t::operator +(stringliteral* leaf) const
{
    Path_t local_copy(*this);
    local_copy.Append(leaf);
    return local_copy;
}


inline Path_t
Path_t::operator +(const utf8* leaf) const
{
    Path_t local_copy(*this);
    local_copy.Append(leaf);
    return local_copy;
}


inline Path_t
Path_t::operator +(const Path_t& leaf) const
{
    Path_t local_copy(*this);
    local_copy.Append(leaf);
    return local_copy;
}


inline Path_t
Path_t::operator +(const String_t& leaf) const
{
    Path_t local_copy(*this);
    local_copy.Append(leaf);
    return local_copy;
}


inline Status_t
Path_t::GetParent(out Path_t* parent) const
{
    static_cast<String_t*>(parent)->Set(*this);
    return parent->ToParent();
}


inline bool
Path_t::IsDelimiter(utf8 c)
{
    if(c == '/')
        return true;
    #if NONSTANDARD_PATH_DELIMITER
        if(c == NONSTANDARD_PATH_DELIMITER)
            return true;
    #endif
    return false;
}


inline Status_t
Path_t::StripCurrAndParentDirs()
{
    if( !StripCurrAndParentDirsInternal(false) )
        return BadPathError( UTF8() );
    return true;
}


inline
PathB_t::PathB_t()
: Path_t( m_buffer, sizeof(m_buffer) )
{ }


inline
PathB_t::PathB_t(stringliteral* path)
: Path_t( m_buffer, sizeof(m_buffer) )
{
    Set(path);
}


inline
PathB_t::PathB_t(const utf8* path)
: Path_t( m_buffer, sizeof(m_buffer) )
{
    Set(path);
}


inline
PathB_t::PathB_t(const Path_t& path)
: Path_t( m_buffer, sizeof(m_buffer) )
{
    Set(path);
}


inline
PathB_t::PathB_t(const String_t& path)
: Path_t( m_buffer, sizeof(m_buffer) )
{
    Set(path);
}


inline const Path_t&
PathB_t::operator =(stringliteral* path)
{
    String_t::Set(path);
    return *this;
}


inline const Path_t&
PathB_t::operator =(const utf8* path)
{
    String_t::Set(path);
    return *this;
}


inline const Path_t&
PathB_t::operator =(const Path_t& path)
{
    String_t::Set(path);
    return *this;
}


inline const Path_t&
PathB_t::operator =(const String_t& path)
{
    String_t::Set(path);
    return *this;
}


#endif // _UT_PATH_H_