Pathname.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PATHNAME_H
#define ZYPP_PATHNAME_H

#include <iostream>
#include <string>

namespace zypp
{ 

  class Url;

  namespace filesystem
  { 

    //
    //  CLASS NAME : Pathname
    //
    class Pathname
    {
    public:
      Pathname()
      : prfx_i( 0 )
      {}

      Pathname( const std::string & name_tv )
      { _assign( name_tv ); }

      Pathname( const char * name_tv )
      { _assign( name_tv ? name_tv : "" ); }

      Pathname & operator=( const Pathname & path_tv )
      {
        prfx_i = path_tv.prfx_i;
        name_t = path_tv.name_t;
        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_t; }

      Url asUrl() const;

      const char * c_str() const
      { return name_t.c_str(); }

      bool empty()    const { return name_t.empty(); }
      bool absolute() const { return !empty() && name_t[prfx_i] == '/'; }
      bool relative() const { return !empty() && name_t[prfx_i] != '/'; }

      Pathname dirname() const { return dirname( *this ); }
      static Pathname dirname( const Pathname & name_tv );

      std::string basename() const { return basename( *this ); }
      static std::string basename( const Pathname & name_tv );

      std::string extension() const { return extension( *this ); }
      static std::string extension( const Pathname & name_tv );

      Pathname absolutename() const { return absolutename( *this ); }
      static Pathname absolutename( const Pathname & name_tv )
      { return name_tv.relative() ? cat( "/", name_tv ) : name_tv; }

      Pathname relativename() const { return relativename( *this ); }
      static Pathname relativename( const Pathname & name_tv )
      { return name_tv.absolute() ? cat( ".", name_tv ) : name_tv; }

      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::size_type prfx_i;
      std::string            name_t;

      void _assign( const std::string & name_tv );
    };

    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 std::ostream & operator<<( std::ostream & str, const Pathname & obj )
    { return str << obj.asString(); }

  } // namespace filesystem

  using filesystem::Pathname;

} // namespace zypp
#endif // ZYPP_PATHNAME_H

---