Pathname.h

Go to the documentation of this file.

 
/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PATHNAME_H
#define ZYPP_PATHNAME_H
 
#include <iosfwd>
#include <string>
 
namespace zypp
{ 
 
  class Url;
 
  namespace filesystem
  { 
 
    //
    //  CLASS NAME : Pathname
    //
    class Pathname
    {
    public:
      Pathname()
      {}
 
      Pathname( const std::string & name_r )
      { _assign( name_r ); }
 
      Pathname( const char * name_r )
      { _assign( name_r ? name_r : "" ); }
 
      Pathname( const Pathname & rhs )
      : _name( rhs._name )
      {}
 
      friend void swap( Pathname & lhs, Pathname & rhs )
      {
        using std::swap;
        swap( lhs._name, rhs._name );
      }
 
      Pathname( Pathname && tmp )
      : _name( std::move( tmp._name ) )
      {}
 
      Pathname & operator=( Pathname rhs )
      { swap( *this, rhs ); return *this; }
 
      Pathname & operator/=( const Pathname & path_tv )
      { return( *this = cat( *this, path_tv ) ); }
 
      Pathname & operator+=( const Pathname & path_tv )
      { return( *this = cat( *this, path_tv ) ); }
 
      const std::string & asString() const
      { return _name; }
 
      static std::string showRoot( const Pathname & root_r, const Pathname & path_r );
 
      static std::string showRootIf( const Pathname & root_r, const Pathname & path_r );
 
      Url asUrl( const std::string & scheme_r ) const;
      Url asUrl() const;
      Url asDirUrl() const;
      Url asFileUrl() const;
 
      const char * c_str() const
      { return _name.c_str(); }
 
      bool empty()    const { return _name.empty(); }
      bool absolute() const { return *_name.c_str() == '/'; }
      bool relative() const { return !( absolute() || empty() ); }
 
      bool emptyOrRoot() const { return( _name.empty() || _name == "/" ); }
 
      Pathname dirname() const { return dirname( *this ); }
      static Pathname dirname( const Pathname & name_r );
 
      std::string basename() const { return basename( *this ); }
      static std::string basename( const Pathname & name_r );
 
      std::string extension() const { return extension( *this ); }
      static std::string extension( const Pathname & name_r );
 
      Pathname absolutename() const { return absolutename( *this ); }
      static Pathname absolutename( const Pathname & name_r )
      { return name_r.relative() ? cat( "/", name_r ) : name_r; }
 
      Pathname relativename() const { return relativename( *this ); }
      static Pathname relativename( const Pathname & name_r )
      { return name_r.absolute() ? cat( ".", name_r ) : name_r; }
 
      Pathname realpath() const;
 
      static Pathname assertprefix( const Pathname & root_r, const Pathname & path_r );
 
      static Pathname stripprefix( const Pathname & root_r, const Pathname & path_r );
 
      Pathname cat( const Pathname & r ) const { return cat( *this, r ); }
      static Pathname cat( const Pathname & l, const Pathname & r );
 
      Pathname extend( const std::string & r ) const { return extend( *this, r ); }
      static Pathname extend( const Pathname & l, const std::string & r );
 
    private:
      std::string _name;
      void _assign( const std::string & name_r );
    };
 
    inline bool operator==( const Pathname & l, const Pathname & r )
    { return l.asString() == r.asString(); }
 
    inline bool operator!=( const Pathname & l, const Pathname & r )
    { return l.asString() != r.asString(); }
 
    inline Pathname operator/( const Pathname & l, const Pathname & r )
    { return Pathname::cat( l, r ); }
 
    inline Pathname operator+( const Pathname & l, const Pathname & r )
    { return Pathname::cat( l, r ); }
 
    inline bool operator<( const Pathname & l, const Pathname & r )
    { return l.asString() < r.asString(); }
 
 
    inline std::ostream & operator<<( std::ostream & str, const Pathname & obj )
    { return str << obj.asString(); }
 
  } // namespace filesystem
 
  using filesystem::Pathname;
 
} // namespace zypp
#endif // ZYPP_PATHNAME_H