Pathname.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
 |                          ____ _   __ __ ___                          |
 |                         |__  / \ / / . \ . \                         |
 |                           / / \ V /|  _/  _/                         |
 |                          / /__ | | | | | |                           |
 |                         /_____||_| |_| |_|                           |
 |                                                                      |
 \---------------------------------------------------------------------*/
#include <iostream>

#include "zypp/base/String.h"
#include "zypp/Pathname.h"
#include "zypp/Url.h"

using std::string;

namespace zypp
{ 

  namespace filesystem
  { 

    namespace
    {
      // Lambda handling the "/.." case:
      // []      + "/.."  ==> []
      // [.]     + "/.."  ==> [./..]
      // [foo]   is always [./foo] due to init above
      // [*/..]  + "/.."  ==> [*/../..]
      // [*/foo] + "/.."  ==> [*]
      inline void goParent_fnc( string & name_t )
      {
        if ( name_t.empty() )
          /*NOOP*/;
        else if ( name_t.size() == 1 ) // content is '.'
          name_t += "/..";
        else
        {
          std::string::size_type pos = name_t.rfind( "/" );
          if ( pos == name_t.size() - 3 && name_t[pos+1] == '.' && name_t[pos+2] == '.' )
            name_t += "/..";
          else
            name_t.erase( pos );
        }
      };

    } // namespace


    //
    //  METHOD NAME : Pathname::_assign
    //  METHOD TYPE : void
    //
    void Pathname::_assign( const string & name_tv )
    {
      prfx_i = 0;
      name_t.clear();
      if ( name_tv.empty() )
        return;
      name_t.reserve( name_tv.size() );

      // Collect up to "/.."
      enum Pending {
        P_none  = 0,    // ""
        P_slash = 1,    // "/"
        P_dot1  = 2,    // "/."
        P_dot2  = 3     // "/.."
      } pending = P_none;

      // Assert relative path starting with "./"
      // We rely on this below!
      if ( name_tv[0] != '/' )
      {
        name_t += '.';
        pending = P_slash;
      }

      // Lambda handling the "/.." case:
      // []      + "/.."  ==> []
      // [.]     + "/.."  ==> [./..]
      // [foo]   is always [./foo] due to init above
      // [*/..]  + "/.."  ==> [*/../..]
      // [*/foo] + "/.."  ==> [*]
#define goParent_f() goParent_fnc( name_t )

      for_each_( it, name_tv )
      {
        const char ch( *it );

        switch ( ch )
        {
          case '/':
            switch ( pending )
            {
              case P_none:      pending = P_slash; break;
              case P_slash:     break;
              case P_dot1:      pending = P_slash; break;
              case P_dot2:      goParent_f(); pending = P_slash; break;
            }
            break;

          case '.':
            switch ( pending )
            {
              case P_none:      name_t += '.'; break;
              case P_slash:     pending = P_dot1; break;
              case P_dot1:      pending = P_dot2; break;
              case P_dot2:      name_t += "/..."; pending = P_none; break;
            }
            break;

          default:
            switch ( pending )
            {
              case P_none:      break;
              case P_slash:     name_t += '/';   pending = P_none; break;
              case P_dot1:      name_t += "/.";  pending = P_none; break;
              case P_dot2:      name_t += "/.."; pending = P_none; break;
            }
            name_t += ch;
            break;
        }
      }

      switch ( pending )
      {
        case P_none:    break;
        case P_slash:   if ( name_t.empty() ) name_t = "/"; break;
        case P_dot1:    if ( name_t.empty() ) name_t = "/"; break;
        case P_dot2:    goParent_f(); if ( name_t.empty() ) name_t = "/"; break;
      }
      return;
    }

    //
    //  METHOD NAME : Pathname::dirname
    //  METHOD TYPE : Pathname
    //
    Pathname Pathname::dirname( const Pathname & name_tv )
    {
      if ( name_tv.empty() )
        return Pathname();

      Pathname ret_t( name_tv );
      string::size_type idx = ret_t.name_t.find_last_of( '/' );

      if ( idx == string::npos ) {
        ret_t.name_t = ".";
      } else if ( idx == 0 ) {
        ret_t.name_t = "/";
      } else {
        ret_t.name_t.erase( idx );
      }

      return ret_t;
    }

    //
    //  METHOD NAME : Pathname::basename
    //  METHOD TYPE : string
    //
    string Pathname::basename( const Pathname & name_tv )
    {
      if ( name_tv.empty() )
        return string();

      string ret_t( name_tv.asString() );
      string::size_type idx = ret_t.find_last_of( '/' );
      if ( idx != string::npos && ( idx != 0 || ret_t.size() != 1 ) ) {
        ret_t.erase( 0, idx+1 );
      }

      return ret_t;
    }

    //
    //  METHOD NAME : Pathname::asUrl
    //  METHOD TYPE : Url
    //
    Url Pathname::asUrl() const
    {
      Url ret( "dir:///" );
      ret.setPathName( asString() );
      return ret;
    }

    std::string Pathname::showRoot( const Pathname & root_r, const Pathname & path_r )
    {
      return str::Str() << "(" << root_r << ")" << path_r;
    }

    std::string Pathname::showRootIf( const Pathname & root_r, const Pathname & path_r )
    {
      if ( root_r.empty() || root_r == "/" )
        return path_r.asString();
      return showRoot( root_r, path_r );
    }

    //
    //  METHOD NAME : Pathname::extension
    //  METHOD TYPE : string
    //
    string Pathname::extension( const Pathname & name_tv )
    {
      if ( name_tv.empty() )
        return string();

      string base( basename( name_tv ) );
      string::size_type pos = base.rfind( '.' );
      switch ( pos )
      {
        case 0:
          if ( base.size() == 1 )                       // .
            return string();
          break;
        case 1:
          if ( base.size() == 2 && base[0] == '.' )     // ..
            return string();
          break;
        case string::npos:
          return string();
          break;
      }
      return base.substr( pos );
    }

    //
    //  METHOD NAME : Pathname::assertprefix
    //  METHOD TYPE : Pathname
    //
    Pathname Pathname::assertprefix( const Pathname & root_r, const Pathname & path_r )
    {
      if ( root_r.empty()
           || path_r == root_r
           || str::hasPrefix( path_r.asString(), root_r.asString() ) )
        return path_r;
      return root_r / path_r;
    }

    //
    //  METHOD NAME : Pathname::cat
    //  METHOD TYPE : Pathname
    //
    Pathname Pathname::cat( const Pathname & name_tv, const Pathname & add_tv )
    {
      if ( add_tv.empty() )
        return name_tv;
      if ( name_tv.empty() )
        return add_tv;

      string ret_ti( name_tv.name_t );
      if( add_tv.name_t[0] != '/' )
        ret_ti += '/';
      return ret_ti + add_tv.name_t;
    }

    //
    //  METHOD NAME : Pathname::Extend
    //  METHOD TYPE : Pathname
    //
    Pathname Pathname::extend( const Pathname & l, const string & r )
    {
      return l.asString() + r;
    }

  } // namespace filesystem
} // namespace zypp