Path.h

Go to the documentation of this file.

#pragma once

#include <filesystem>
#include <string>
#include <codecvt>

namespace filesystem
{

namespace experimental = std::tr2::sys;

class Path
{
private:
    experimental::path      m_path;

public:

    explicit                Path            ();
                            Path            ( const Path& path );
                            Path            ( Path&& path );
                            Path            ( const std::wstring& path );

    template< class Source >
                            Path            ( const Source& source );


    Path&                   operator=		( const Path& other );
    Path&                   operator=		( Path&& other );

    Path&                   operator/=		( const Path& other );
    bool                    operator==		( const Path& other ) const;
    bool                    Compare         ( const Path& path1, const Path& path2 );

    friend Path             operator/		( const Path& path1, const Path& path2 );

    std::string             String          () const;


    std::string             GetFileName     () const;
    std::string             GetExtension    () const;
    Path                    GetParent       () const;
    Path                    GetDirectory    () const;

    void                    Normalize       ();


    bool                    HasRoot         () const;
    bool                    HasFileName     () const;
    bool                    HasExtension    () const;

    bool                    IsRelative      () const;
    bool                    IsAbsolut       () const;

    bool                    Exists          () const;

    static Path             WorkingDirectory();

public:
    const experimental::path&       GetStdPath      () const;
};


template< class Source >
inline      Path::Path      ( const Source& source )
    :   m_path( experimental::path( source ) )
{}

inline      Path::Path()
{}

inline      Path::Path      ( const Path& path )
    :   m_path( path.m_path )
{}

inline      Path::Path      ( Path&& path )
    :   m_path( std::move( path.m_path ) )
{}

inline      Path::Path      ( const std::wstring& path )
{
    typedef std::codecvt_utf8< wchar_t > ConvertType;
    std::wstring_convert< ConvertType, wchar_t > converter;
    auto pathStr = converter.to_bytes( path );

    m_path = experimental::path( pathStr );
}

inline Path&    Path::operator=		( const Path& other )
{
    m_path = other.m_path;
    return *this;
}

inline Path&    Path::operator=		( Path&& other )
{
    m_path = std::move( other.m_path );
    return *this;
}

inline Path&    Path::operator/=	( const Path& other )
{
    m_path /= other.m_path;
    return *this;
}

inline bool     Path::operator==	( const Path& other ) const
{
    return experimental::equivalent( m_path, other.m_path );
}

inline bool     Path::Compare       ( const Path& path1, const Path& path2 )
{
    return experimental::equivalent( path1.m_path, path2.m_path );
}

inline std::string      Path::String() const
{
    return m_path.string();
}

inline std::string      Path::GetFileName() const
{
    return m_path.filename().string();
}

inline std::string      Path::GetExtension() const
{
    return m_path.extension().string();
}

inline Path             Path::GetParent() const
{
    return m_path.parent_path();
}

inline Path             Path::GetDirectory() const
{
    if( m_path.has_filename() )
        return GetParent();
    else
        return Path( *this );
}

inline void             Path::Normalize()
{
    //m_path = experimental::complete( m_path );
}

inline bool             Path::HasRoot() const
{
    return m_path.has_root_directory();
}

inline bool             Path::HasFileName() const
{
    return m_path.has_filename();
}

inline bool             Path::HasExtension() const
{
    return !GetExtension().empty();
}

inline bool             Path::IsRelative() const
{
    return !IsAbsolut();
}

inline bool             Path::IsAbsolut() const
{
    return m_path.has_root_name() && m_path.has_root_directory();
}

inline bool             Path::Exists() const
{
    return experimental::exists( m_path );
}

// ================================ //
//
inline Path             Path::WorkingDirectory()
{
    return experimental::current_path();
}

inline Path             operator/( const Path& path1, const Path& path2 )
{
    Path newPath = path1;
    newPath /= path2;
    return newPath;
}

inline const experimental::path&    Path::GetStdPath() const
{
    return m_path;
}

}