New function to check if two files differ: file_content_differs()

[libi2ncommon] / src / filefunc.hxx

/*
The software in this package is distributed under the GNU General
Public License version 2 (with a special exception described below).

A copy of GNU General Public License (GPL) is included in this distribution,
in the file COPYING.GPL.

As a special exception, if other files instantiate templates or use macros
or inline functions from this file, or you compile this file and link it
with other works to produce a work based on this file, this file
does not by itself cause the resulting work to be covered
by the GNU General Public License.

However the source code for this file must still be made available
in accordance with section (3) of the GNU General Public License.

This exception does not invalidate any other reasons why a work based
on this file might be covered by the GNU General Public License.
*/
/***************************************************************************
 *   Copyright (C) 2004-2008 by Intra2net AG                                    *
 *                                                                         *
 ***************************************************************************/

#ifndef __FILEFUNC_HXX
#define __FILEFUNC_HXX

#include "userfunc.hpp"
#include <set>

namespace I2n
{
/**
 * @brief helper class representing a file state.
 *
 * This basically wraps struct stat and provides some nicer access to the values.
 */
class Stat
{
public:
      Stat();
      Stat(const std::string& path, bool follow_links= true);
      ~Stat();

   void recheck();

   bool is_valid() const { return Valid; }

   bool exists() const { return Valid; }
   std::string path() const { return Path; }

   dev_t   device() const { return Device; }
   ino_t   inode() const { return Inode; }
   mode_t  mode() const { return Mode; }
   nlink_t nlink() const { return NumLinks; }
   uid_t   uid() const { return Uid; }
   gid_t   gid() const { return Gid; }
   dev_t   rdev() const { return DeviceType; }
   off_t   size() const { return Size; }
   time_t  atime() const { return Atime; }
   time_t  mtime() const { return Mtime; }
   time_t  ctime() const { return Ctime; }

   nlink_t num_hard_links() const { return NumLinks; }
   dev_t   device_type() const { return DeviceType; }
   time_t  last_modified_time() const { return Mtime; }
   time_t  created_time() const { return Ctime; }

   /*
   ** unix style like type queries:
   */

   bool is_lnk() const { return IsLink; }
   bool is_reg() const { return IsRegular; }
   bool is_dir() const { return IsDirectory; }
   bool is_chr() const { return IsCharacterDevice; }
   bool is_blk() const { return IsBlockDevice; }
   bool is_fifo() const { return IsFifo; }
   bool is_sock() const { return IsSocket; }

   /*
   **  readable style type queries:
   */

   bool is_link () const { return IsLink; }
   bool is_regular() const { return IsRegular; }
   bool is_regular_file() const { return IsRegular; }
   bool is_directory() const { return IsDirectory; }
   bool is_character_device() const {return IsCharacterDevice; }
   bool is_block_device() const { return IsBlockDevice; }
   bool is_socket() const { return IsSocket; }

   bool is_device() const { return IsCharacterDevice or IsBlockDevice; }


   /*
   ** "high level" queries
   */

   bool is_same_as(const Stat& rhs);
   bool is_same_device_as(const Stat& rhs);

   /*
   ** convenience methods
   */

   operator bool() const { return Valid; }

protected:

   void stat(const std::string& path, bool follow_links= true);
   void clear();

protected:
   std::string Path;
   bool FollowLinks;

   bool Valid;

   dev_t   Device;
   ino_t   Inode;
   mode_t  Mode;
   nlink_t NumLinks;
   uid_t   Uid;
   gid_t   Gid;
   dev_t   DeviceType;
   off_t   Size;
   time_t  Atime;
   time_t  Mtime;
   time_t  Ctime;

   bool IsLink : 1;
   bool IsRegular : 1;
   bool IsDirectory : 1;
   bool IsCharacterDevice : 1;
   bool IsBlockDevice : 1;
   bool IsFifo : 1;
   bool IsSocket : 1;
}; // eo class Stat

/*
** misc tool functions
** (basically wrappers around system functions)
*/

bool path_exists(const std::string& path);
bool file_exists(const std::string& path);
long file_size (const std::string &name);
bool file_content_differs(const std::string &old_filename, const std::string &new_filename);

time_t file_mtime(const std::string& path);

bool get_dir(const std::string& path, std::vector< std::string >& result, bool include_dot_names= false );
std::vector< std::string > get_dir(const std::string& path, bool include_dot_names= false );

bool unlink(const std::string& path);

bool symlink(const std::string& target, const std::string& link_name, bool force= false);

std::string read_link(const std::string& path);

std::string read_file(const std::string& path);

bool write_file(const std::string& path, const std::string& data, bool trunc=true);

bool copy_file(const std::string& src, const std::string& dest);
bool copy_stream(std::istream& is, std::ostream& os);

std::string basename(const std::string& path);

std::string dirname(const std::string& path);

std::string normalize_path(const std::string& path);

bool dirsync(const std::string& path);

bool chmod(const std::string& path, int mode);
bool chown(const std::string& path, const I2n::User& user, const I2n::Group& group= I2n::Group());

bool recursive_delete(const std::string &path, std::string *error=NULL);

std::string mkdtemp(const std::string &path_template, std::string *error=NULL);
bool mkdir(const std::string &path, const mode_t &mode=0700, std::string *error=NULL);
bool rmdir(const std::string &path, std::string *error=NULL);

std::string getcwd();
bool chdir(const std::string &path, std::string *error=NULL);

mode_t umask(mode_t mask);


/*
** more specialized tool function(s)
*/
bool remove_unlisted_files(const std::string &directory, const std::set<std::string> &keep_files,
                                            const std::string &prefix="");

}

#endif