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 );
      }
#ifndef SWIG // Swig treats it as syntax error

      Pathname( Pathname && tmp )
      : _name( std::move( tmp._name ) )
      {}
#endif

      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() ); }

      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; }

      static Pathname assertprefix( 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