---

more/io/filesys.h

Go to the documentation of this file.

//  Copyright (C) 1999--2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This 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 file 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.
//
//  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
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: filesys.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $



#ifndef MORE_FILESYS_H
#define MORE_FILESYS_H

#include <string>
#include <list>
#include <stdexcept>


namespace more {
namespace io {

  /** Rename a file or a directory.  Returns true iff successful. */
  bool rename_node(std::string const& oldpath, std::string const& newpath);

  /** Remove a file or a directory.  Returns true iff successful. */
  bool remove_node(std::string const& path);

  /** Remove all files in a directory and the directory itself, USE
      WITH CARE! Returns true iff successful. */
  bool remove_node_rec(std::string const& path);

  /** Calls remove(path) at exit. */
  void remove_node_at_exit(std::string const& path);

  /** Calls remove_recursive(path) at exit, USE WITH CARE! */
  void remove_node_rec_at_exit(std::string const& path);

  /** Copy node \a srcpath to \a dstpath.  Directories will only be
   ** created without copying contents. */
  bool copy_node(std::string const& srcpath, std::string const& dstpath);

  /** Copy node \a srcpath to \a dstpath, recursively copying
   ** directory contents.  */
  bool copy_node_rec(std::string const& srcpath, std::string const& dstpath);

  /** Create a directory.  Returns true iff successful. */
  bool create_dir(std::string path);

  /** Create a directory after first creating all nonexisting parents
      directories.  Returns true iff successful. */
  bool create_dir_rec(std::string path);

  /** Returns true iff the file at path contains str. This version
      searches line by line, so str should not contain any
      newlines. */
  bool grep_string(std::string const& path, std::string const& str);

  /** Attempts to reserve a unique file name starting with \a name.
      If it succeeds, an empty file with permissions 0600 (Unix) will
      be created, name is modified to the name of this file and true
      is returned.  Otherwise false is returned.  The file will be
      removed at exit if remove_p=true.  If remove_p == true, do not
      remove the file yourself, as some other application may then
      reuse the file name and loose its file the file when your
      program exits! */
  bool reserve_tmp_file(std::string& name, bool remove_p = true);

  /** A handle to a unique name of a file that will be removed when
      the handle is destructed.  An empty file with permissions 0600
      is created. */
  struct tmp_file_reservation
  {
      /** Attempt to reserve the file. */
      explicit tmp_file_reservation(std::string const& name)
          : m_name(name)
      {
          if (!reserve_tmp_file(m_name, false))
              m_name.clear();
      }

      /** Remove the file. */
      ~tmp_file_reservation()
      {
          if (!m_name.empty())
              remove_node(m_name);
      }

      /** Returns the reserved file name, or throws a runtime_error if
          not reserved. */
      std::string const& name()
      {
          if (m_name.empty())
              throw std::runtime_error("more::tmp_file_reservation::name: "
                                       "Could not reserve a tmp file.");
          return m_name;
      }

      /** True of a file name was reserved. */
      bool is_reserved() const { return !m_name.empty(); }

    private:
      std::string m_name;
  };

  /** Attemts to create a directory with a name starting with name.
      If it succeeds, returns true and there will be a newly created
      directory with permissions 0700 (Unix).  Otherwise returns
      false.  The directory and its contents will be removed at
      exit.  */
  bool create_tmp_dir(std::string& name);

//   std::string mkpath(const std::string, const std::string);
//   std::string path_file(const std::string);
//   std::string path_directory(const std::string);
//   std::string path_parent(const std::string);

  /** Aquires various information about the a file. */
  struct file_status
  {
      static const int readable_flag = 4;
      static const int writable_flag = 2;
      static const int executable_flag = 1;

      file_status(std::string);
      ~file_status();

      bool good() const { return m_err == 0; }
      bool bad() const { return m_err != 0; }

      int user_permissions() const;
      int permissions() const;
      unsigned int uid() const;
      unsigned int gid() const;

      bool exists() const { return good(); }
      bool is_readable() const { return user_permissions() & readable_flag; }
      bool is_writable() const { return user_permissions() & writable_flag; }
      bool is_executable() const {return user_permissions()&executable_flag;}

      bool is_regular_file() const;
      bool is_directory() const;
      bool is_symbolic_link() const;

      double atime() const;
      double mtime() const;

    private:
      void*     m_stat;
      int       m_err;
  };


  /** A list of path names matched by a globbing pattern. */
  struct file_glob_list
  {
      /** The iterator should be at least a bidirectional iterator. */
      typedef char const* const* iterator;
      /** The iterator should be at least a bidirectional iterator. */
      typedef char const* const* const_iterator;

      file_glob_list(std::string patt);
      ~file_glob_list();

      /** True unless a read error occured.  Note that no matches
          results in an empty list, but good() still returns true. */
      bool good() const { return m_data; }

      const_iterator begin() const;
      const_iterator end() const;

    private:
      void* m_data;
  };

  typedef std::list<std::string> list_of_string;
  typedef list_of_string::iterator list_of_string_iterator;
  typedef list_of_string::const_iterator const_list_of_string_iterator;


  // scsh style file-name manipulation

  bool          is_file_name_directory(std::string fname);
  bool          is_file_name_non_directory(std::string fname);
  std::string   file_name_as_directory(std::string fname);
  std::string   directory_as_file_name(std::string fname);
  bool          is_file_name_absolute(std::string fname);
  std::string   file_name_directory(std::string fname);
  std::string   file_name_nondirectory(std::string fname);
  std::pair<std::string, std::string>
                split_file_name(std::string fname);
  std::string   path_list_to_file_name(const_list_of_string_iterator first,
                                       const_list_of_string_iterator past_end,
                                       std::string dir = ".");
  std::string   file_name_extension(std::string fname);
  std::string   file_name_sans_extension(std::string fname);
  std::string   replace_extension(std::string fname, std::string ext);
  std::string   resolve_file_name(std::string fname, std::string dir = ".");
  std::string   absolute_file_name(std::string fname, std::string dir = ".");
  std::string   relative_file_name(std::string fpath, std::string dir);
  std::string   current_directory();
  std::string   home_dir(/* XXX std::string user = "" */);
  std::string   home_file(std::string fname);

}}

#endif

---