file.h

Go to the documentation of this file.

#ifndef FILE_HEADER_INCLUDED
#define FILE_HEADER_INCLUDED

//
// Copyright 2002, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.

#include <string>
#include <string.h>
#include <memory>
#include <sys/types.h>
#include <time.h>
#include <sys/stat.h>
#include <iostream>
#include <list>
#include <set>
#include <memory>
#include <cxxtls/strtool.h>

namespace cxxtls
{


//========================================================================================
//========================================================================================
//========================================================================================

struct FileTime
{
  int year;     
  int month;    
  int day;      
  int hour;     
  int minute;   
  int second;   

  friend bool operator<(FileTime const &l, FileTime const &r)
  {
      if(l.year < r.year)
         return true;
      else
      if(l.year > r.year)
        return false;


      if(l.month < r.month)
         return true;
      else
      if(l.month > r.month)
        return false;


      if(l.day < r.day)
         return true;
      else
      if(l.day > r.day)
        return false;


      if(l.hour < r.hour)
         return true;
      else
      if(l.hour > r.hour)
        return false;


      if(l.minute < r.minute)
         return true;
      else
      if(l.minute > r.minute)
        return false;


      if(l.second < r.second)
         return true;
      else
      if(l.second > r.year)
        return false;


      return false;
  }


  operator std::string() const;

  friend std::ostream& operator<< (std::ostream& o, FileTime const &r)
  {
    return o << std::string(r);
  }

  FileTime()       
  : year(0),
    month(0),
    day(0),
    hour(0),
    minute(0),
    second(0)
  {
  }

  FileTime(struct tm const *);     

  FileTime(std::string s)          
  : year(0),
    month(0),
    day(0),
    hour(0),
    minute(0),
    second(0)
  {
    construct_from_string(s);
  }

  bool construct_from_string(std::string s);

  std::string short_string() const;
};

//========================================================================================
//========================================================================================
//========================================================================================

struct FileMode
{
  int mode;  



  int os_mode() const;  




  operator std::string() const;   

  friend std::ostream& operator<< (std::ostream& o, FileMode const &r)
  {
    return o << std::string(r);
  }

  FileMode(): mode(0) {}   

  FileMode(int m);

  FileMode(char const*s)
  {
    construct_from_string(s);
  }

  FileMode(std::string s)
  {
    construct_from_string(s.c_str());
  }

  void construct_from_string(char const *string);

  void construct_from_string(std::string const& s)
  {
    construct_from_string(s.c_str());
  }


  enum bit_name
  {
       link     = 010000,  
       directory= 004000,  
       set_uid  = 002000,
       set_gid  = 001000,

       user_readable   = 000400,  
       user_writeable  = 000200,  
       user_executable = 000100,

       group_readable  = 000040,
       group_writeable = 000020,
       group_executable= 000010,

       world_readable   = 000004,
       world_writeable  = 000002,
       world_executable = 0000001
  };

  bool is_dir() const { return mode & directory; }

  bool is_link() const { return mode & link; }


  void unpackPermissions(std::string &userMode, std::string &groupMode, std::string &worldMode);

  void packPermissions(std::string const &userMode, std::string const &groupMode, std::string const &worldMode);

   bool permStringValid(std::string const &string);
};

//========================================================================================
//========================================================================================
//========================================================================================

struct FileStatus
{
   typedef off_t file_size_t;   

   FileMode     mode;           
   file_size_t  size;           
   FileTime     time;           
   int          owner_id;       
   int          group_id;       

   FileStatus()
   : mode(),
     size(0),
     time(),
     owner_id(0),
     group_id(0)
   {
       // this constructor is needed to prevent a gcc warning that some members of the
       // class are uninitialized
   }

   std::string convert_to_string(bool resolve_id_names=false) const;

   operator std::string() const
   {
     return convert_to_string();
   }

   friend std::ostream& operator<< (std::ostream& o, FileStatus const &r)
   {
     return o << std::string(r);
   }

   static std::string id2string(int id);

   static std::string group2string(int id);  // use this to convert group_id to strings

};

//========================================================================================
//========================================================================================
//========================================================================================

class FileContents
{
private:

   char *begin_;         
   char *end_;           
   char const *error_;   

public:

   FileContents()        
   : begin_(0),
     end_(0),
     error_("not read yet")
   {
   }

   ~FileContents()       
   {
     delete [] begin_;
   }

   typedef char *iterator;               
   typedef char const *const_iterator;   

   const_iterator begin() const { return begin_; }

   const_iterator end()   const { return end_;   }

   iterator begin() { return begin_; } 
   iterator end()   { return end_;   } 

   void reserve(long bytes) { delete [] begin_; begin_ = new char[bytes]; end_ = begin_ + bytes; }

   long size() const { return end_ - begin_; }  

   char const *error() const { return error_; }

   void set_error(char const *msg) { error_ = msg ; }

   void clear_error() { error_ = 0; }

   bool ok() const { return error_ == 0; }


};

//========================================================================================
//========================================================================================
//========================================================================================



class FileName
{
public:

  struct FileNameSorter
  {
     bool operator()(FileName const &a, FileName const &b) const 
          { return  0 > StrTool:: compareInsensitive(a,b); }
  };

  typedef std::set<FileName, FileNameSorter> sorted_names_t; 

  typedef std::string              rep_t;          
  typedef FileStatus::file_size_t  off_t;          
  typedef rep_t::const_iterator    const_iterator; 
  typedef rep_t::iterator          iterator;       

private:
  rep_t             impl_;   

public:

  operator std::string       &()            { return impl_; }         
  operator std::string const &() const      { return impl_; }         
  const_iterator              begin() const { return impl_.begin(); } 
  const_iterator              end()   const { return impl_.end();   } 
  size_t                      size()  const { return impl_.size(); }  
  iterator                    begin()       { return impl_.begin(); } 
  iterator                    end()         { return impl_.end();   } 
  char const *                c_str() const { return impl_.c_str(); } 
  char const *                data()  const { return impl_.data();  } 

  char operator[](size_t i) const { return impl_[i]; }   


  char &operator[](size_t i) { return impl_[i]; }   


  void erase(iterator a)                { impl_.erase(a);    } 
  void erase(iterator a, iterator b)    { impl_.erase(a,b);  } 
  void erase(size_t o, size_t l)        { impl_.erase(o,l);  } 
  void erase(size_t o)                  { impl_.erase(o);    } 
  void insert(iterator a, char c)       { impl_.insert(a,c); } 
  void insert(size_t o, char const *s)  { impl_.insert(o,s); } 
  void insert(size_t o, rep_t const &s) { impl_.insert(o,s); } 
  bool empty() const                    { return impl_.empty(); } 

  bool operator<( std::string const &rhs ) const
  {
    return impl_ < rhs; 
  }

  rep_t substr(size_t s, size_t l) const 
  { 
      return impl_.substr(s,l); 
  } 

  FileName &operator+= (char const *p)  
  {
     std::string *me = &impl_;

     *me += p;

     return *this;
 
  }

  FileName &operator+= (char c) 
  {
     std::string *me = &impl_;

     *me += c;

     return *this;

  }


  FileName &operator+= (std::string const &r) 
  {
     std::string *me = &impl_;

     *me += r;

     return *this;

  }


  FileName()  
  {
  }

  FileName(char const *r)  
  : impl_(r)
  {
  }

  FileName(std::string const &r) 
  : impl_(r)
  {
  }

  FileName(FileName const &r) 
  : impl_(r)
  {
  }


  FileName expand_tildes() const;

  rep_t basename(bool remove_extension=false) const;

  rep_t extension() const;

  rep_t dirname()  const;

  void  convert_to_absolute_path();

  bool  is_syntactically_valid() const;

  bool  exists() const;

  bool  is_dir() const;                     
  bool  is_executable() const;              
  bool  is_writeable() const;               
  bool  is_readable() const;                
  bool  is_createable() const;              
  bool  is_absolute_path() const;           
  bool  is_root_dir() const;                

  FileMode file_mode() const;               
  off_t    file_size() const;               

  bool  file_time(FileTime *t) const;       

  bool  file_stat(FileStatus* s, bool l=false) const;


  bool  matches(char const *pattern) const; 

  bool  matches(rep_t pattern) const        
  { 
    return matches(pattern.c_str()); 
  }


  FileName readlink(int *returnedMode=0) const; 


  bool remove() const;                      

  bool chmod(FileMode) const;


  bool copy(FileName const &destination) const;

  bool rename(FileName const &destination) const;

  bool mkdir(FileMode m=FileMode(" drwxrwxrwx") ) const;

  bool rmdir() const;

  void convertToDirectorySearchPattern(std::string const &pattern)
  {
      convertToDirectorySearchPattern(pattern.c_str());
  }
  
  void convertToDirectorySearchPattern(char const *pattern="*");


  static int find_matching(char const     *pattern, 
                           sorted_names_t *matches, 
                           int             options=0
                          );


  static int find_matching(rep_t           pattern, 
                           sorted_names_t* l, 
                           int             options=0
                          )
  { 
    return find_matching(pattern.c_str(), l, options); 
  }

  void slurp(FileContents *f) const ;

  bool write(std::string const &file_contents, bool binary_mode=true);

  bool write(char const *begin, char const *end, bool binary_mode=true);
    //   @return true if a failure occurs.  See errno.

  size_t slurp(std::list<std::string> *lines) const;

  struct accumulate_lines
  {
    virtual ~accumulate_lines(){}

    virtual void push_back(std::string const &new_line) = 0;

    virtual std::string &back() = 0;

    virtual void setBackHasCR(bool flag){ }
           
  };

  std::string read_lines(accumulate_lines &accum, size_t *line_count_ptr=0, bool removeCR=false);

  template<class Container>
  struct Accum
  : public accumulate_lines
    {
      Container& container_;

      Accum(Container& container)
      : container_(container)
      {
      }

      void push_back(std::string const &s) { container_.push_back(s); }
      std::string & back()                 { return container_.back();}

    };

  template<class Container>
  std::string read_file(Container &container, size_t* line_count_ptr=0)
  {

    Accum<Container> accum(container);

    return read_lines( accum, line_count_ptr );

  }


  static FileName mktemp(FileName dir="./");


  static char PATH_separator;  



                        
  struct is_separator
  {
    bool operator() (char c) const
    {
      return c == FileName::PATH_separator;
    }
  };

  static FileName find_executable(std::string progname, std::string path="");

  static FileName find_file_in_path(std::string filename, std::string path="");

  std::string shorten(int max_chars) const;

  FileName operator+(FileName const &r ) const 
  {
    std::string const &me = *this;
    std::string const &other = r;


    return FileName(me + other);
  }

  FileName operator+(char const* r) const
  {
    std::string const &me = *this;


    return FileName(me + r);
  }

  FileName operator+(std::string const &r) const
  {
    std::string const &me = *this;


    return FileName(me + r);
  }

  template<class T>
  FileName &operator=(T const &rhs)
  {
     impl_ = rhs;

     return *this;
  }



  friend std::string operator+(std::string const &lhs, FileName const&rhs)
  {
    return lhs + (std::string const &)(rhs);
  }

  friend std::string operator+(char const *lhs, FileName const&rhs)
  {
    return lhs + (std::string const &)(rhs);
  }

  static int compareIgnoringPathSeparatorDifferences(char const *l,
                                                     char const *r,
                                                     size_t      lsize,
                                                     size_t      rsize
                                                    )
  {


     size_t smaller = lsize < rsize ? lsize : rsize;

     for(size_t i = 0; i < smaller; ++i)
     {
         char lc = l[i];
         char rc = r[i];

         if(lc == '\\')
            lc = '/';

         if(rc == '\\')
           rc = '/';

         if(lc < rc)
            return -1;

         if(lc > rc)
            return 1;

         // the characters are equal, so keep comparing.


     }

     // if we get here, the two strings are euqal up in the range [0..smaller-1].
     // which represents the common sub-range of the the two strings.

     if(lsize < rsize)
        return -1;
     else
     if(lsize > rsize)
       return 1;

     return 0; // strings are equal

      
  }

  static int compareIgnoringPathSeparatorDifferences(std::string const &l,
                                                     std::string const &r
                                                    )
  {
      return compareIgnoringPathSeparatorDifferences(l.data(), r.data(), l.size(), r.size());
      
  }



  bool operator==(FileName const rhs) const
  {
    int cmp = compareIgnoringPathSeparatorDifferences(*this, rhs);

    if(cmp != 0)
       return false;

    return true;


    // return ((std::string const &)(*this)) == (std::string const&)(rhs);
  }

  bool operator==(std::string const rhs) const
  {

    int cmp = compareIgnoringPathSeparatorDifferences(this->data(), rhs.data(), this->size(), rhs.size());

    if(cmp != 0)
       return false;

    return true;

    // return ((std::string const &)(*this)) == rhs;
  }

  bool operator==(char const *rhs) const
  {
    int cmp = compareIgnoringPathSeparatorDifferences(this->data(), rhs, this->size(), strlen(rhs));

    if(cmp != 0)
       return false;

    return true;

    
    return ((std::string const &)(*this)) == rhs;
  }


  friend bool operator==(std::string const &lhs, FileName const& rhs)
  {

    int cmp = compareIgnoringPathSeparatorDifferences(lhs, rhs);

    if(cmp != 0)
       return false;

    return true;

    // return lhs == (std::string const &)(rhs);
  }

  friend bool operator==(char const*lhs, FileName const& rhs)
  {

    int cmp = compareIgnoringPathSeparatorDifferences(lhs, rhs.data(), strlen(lhs), rhs.size());

    if(cmp != 0)
       return false;

    return true;
    
    // return lhs == (std::string const &)(rhs);
  }

  static FileName getcwd(); 

  class Tree
  {
  public:
     typedef std::list<Tree*> children_t; 

     friend class FileName;  

  private:

     FileStatus      status_;   
     std::string     name_;     
     children_t      children_; 

     Tree*           parent_;   

     int             depth_;    

  public:

      Tree(Tree* parent=0) 
      : parent_(parent),
        depth_(0)
      {
      } 

     ~Tree();               
      Tree(Tree const &r);  

      Tree(std::string const &name, FileStatus const &status, Tree* parent=0, int depth=0)
      : status_(status),
        name_(name),
        parent_(parent),
        depth_(0)
      {
      }

      Tree &operator=(Tree const &r)
      {
        this->~Tree();       // delete self
        new (this) Tree(r);  // copy construct from r
        return *this;
      }


      FileStatus const&  status() const   { return status_; }

      FileName           name() const     { return name_;   }

      FileName           path() const;

      int                depth() const  { return depth_; }

      children_t  const&  children() const { return children_; }

      void add_child(FileName const &name, FileStatus const &status)
      {
          children_.push_back(new Tree(name,status,this,this->depth_+1));
      }

      void add_child(Tree *tree)
      {
        tree->parent_ = this;
        tree->depth_  = depth_+1;
        children_.push_back(tree);
      }

      void remove_child(FileName const &name);

  };

  std::auto_ptr<Tree> tree(bool only_dirs=false) const;

private:
    std::auto_ptr<Tree> 
    tree_helper(std::string const &path, bool only_dirs=false, int depth=0) const;
};

//========================================================================================
//========================================================================================
//========================================================================================

inline std::ostream &operator<< (std::ostream &s, FileName const &rhs)
{
    std::string const &data = rhs;

    return s << data;
}

//========================================================================================
//========================================================================================
//========================================================================================
template<class T>
inline bool operator!= (FileName const &lhs, T const &rhs)
{
    std::string const &data = lhs;

    return data != rhs;

}

//========================================================================================
//========================================================================================
//========================================================================================
template<class T>
inline bool operator!= (T const &lhs, FileName const &rhs)
{
    std::string const &data = rhs;

    return data != rhs;

}



} // namespace cxxtls

#endif