base/PathName

Go to the documentation of this file.

/****************************************************************************
  Copyright (C)1996 David Jung <opensim@pobox.com>

  This program/file is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details. (http://www.gnu.org)
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  $Id: PathName 1029 2004-02-11 20:45:54Z jungd $
  $Revision: 1.3 $
  $Date: 2004-02-11 15:45:54 -0500 (Wed, 11 Feb 2004) $
  $Author: jungd $
 
****************************************************************************/

#ifndef _BASE_PATHNAME_
#define _BASE_PATHNAME_

#include <base/base>
#include <base/array>
#include <base/Object>
#include <base/Cloneable>
#include <base/PathComponent>

#include <stdexcept>

namespace base {


class PathName : public Object, public Cloneable
{
public:
  PathName();
  PathName(const String& name) throw(std::invalid_argument);
  PathName(const PathName& pn);
  virtual ~PathName();
  
  virtual String className() const { return String("PathName"); }

  static const char separator = '/';
  static const String currentDirectory; // "."
  static const String parentDirectory;  // ".."

  static bool validName(const String& name) { return true; } //!!! should check for no '/'s, only one '.', first is alpha etc.
  static bool validPath(const String& name) { return true; } //!!! should check for valid dir name

  virtual void parent();
  virtual void canonical();  // resolves path to contain no '..' path components
  virtual String str() const;
  virtual PathName path() const;
  virtual PathName name() const;
  virtual String extension() const;
  virtual bool isRelative() const;
  virtual bool isAbsolute() const;
  virtual bool isSimple() const;

  virtual PathName& prepend(const String& prefix);

  virtual Int size() const;
  virtual bool empty() const;
  virtual String operator[](Int i) const;
  virtual String operator()(Int i) const;

  virtual bool operator==(const PathName& pn) const;
  virtual bool operator!=(const PathName& pn) const;
  virtual bool operator==(const String& pn) const;
  virtual bool operator!=(const String& pn) const;
  virtual PathName& operator=(const PathName& pn);
  virtual PathName& operator+=(const PathName& pn);
  virtual Object& clone() const;

protected:
  bool relative;
  typedef array<PathComponent> PathComponents;
  PathComponents _path;
};


// Operations

inline bool PathName::isRelative() const
{ return relative; }

inline bool PathName::isAbsolute() const
{ return !relative; }

inline bool PathName::isSimple() const
{ return relative && (_path.size()==1); }

inline PathName& PathName::prepend(const String& prefix)
{
  PathName newpn(prefix); newpn += *this;
  *this = newpn;
  return *this;
}

inline Int PathName::size() const
{ return _path.size(); }

inline bool PathName::empty() const
{ return (_path.size()==0); }

inline String PathName::operator[](Int i) const
{
  if ((i < 0) || (i>=size()))
    throw std::out_of_range(Exception("path component index out of range"));
  return _path[i].name();
}

inline String PathName::operator()(Int i) const
{ return operator[](i-1); }

inline PathName operator+(const PathName& p1, const PathName& p2)
{ PathName r(p1); return r+=p2; }

inline PathName operator+(const PathName& p, const String& s)
{ PathName r(p); return r+=PathName(s); }





} // base

#endif

---