source: trunk/lib/utility.h @ 724

#ifndef _theplu_svndigest_utility_
#define _theplu_svndigest_utility_

// $Id: utility.h 724 2008-12-09 13:34:16Z peter $

/*
  Copyright (C) 2005, 2006, 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Jari Häkkinen

  This file is part of svndigest, http://dev.thep.lu.se/svndigest

  svndigest 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 3 of the License, or
  (at your option) any later version.

  svndigest 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 svndigest. If not, see <http://www.gnu.org/licenses/>.
*/

#include <algorithm>
#include <functional>
#include <iosfwd>
#include <sstream>
#include <string>
#include <stdexcept>
#include <utility>
#include <vector>

#include <sys/stat.h>

namespace theplu{
namespace svndigest{

  ///
  /// @brief Check if access permissions match \a mode. \a mode must
  /// be given as r, w, x, or combinations of these letters.
  ///
  /// @return On success (all requested permissions granted), zero
  /// is returned. On error (at least one bit in mode asked for a
  /// permission that is denied, or some other error occurred), -1
  /// is returned, and errno is set appropriately.
  ///
  /// @throw An std::runtime_error is thrown when checking for write
  /// permissions for a file/direcotry that does not exist.
  ///
  /// @see access(2)
  ///
  int access_rights(const std::string& path,const std::string& bits);

  /**
     \return dir+base if dir ends with '/', else dir+'/'+base
   */
  std::string concatenate_path(std::string dir, std::string base);

  /**
     \brief convert string to (numerical) type

     \throw runtime_error if conversion fails
   */
  template<typename T>
  T convert(const std::string& s);

  /**
     @brief Copy file \a source to \a target.

     @throw std::runtime_error when read error of \a source or write
     error for \a target is encountered.
  */
  void copy_file(const std::string& source, const std::string& target);

  /**
     Parsing out the directory of path that is everything prior the
     last '/' with the eception if \a path ends with '/' in which case
     everything prior the second last '/' is returned.

     \return directory of path.
   */
  std::string directory_name(std::string path);

  /**
     Function to compare strings. Strings may contain '*'.

     \return true if \a a and \a b are identical. 
   */
  bool equal(std::string::const_iterator first1, 
             std::string::const_iterator end1,
             std::string::const_iterator first2,
             std::string::const_iterator end2);

  ///
  /// @return everything after last '/'
  ///
  std::string file_name(const std::string&);

  ///
  /// @brief environment variable @a var
  ///
  std::string getenv(const std::string& var); 

  ///
  /// If @a width is set, size is forced to length @a width. This
  /// implies, e.g., that hex(15,2) and hex(17,1) return "0F" and "1",
  /// respectively.
  ///
  /// @return x in hexadecimal base
  ///
  std::string hex(int x, unsigned int width=0);

  ///
  /// @brief remove trailing whitespaces
  ///
  std::string htrim(std::string str);

  /**
     @return true if string \a s fulfills regular expression \verbatim
     ^\w* \endverbatim \a other \verbatim \w*$ \endverbatim (case
     insensitive)
  */
  bool is_equal(std::string s, std::string other);

  ///
  /// @return true if \a str is an integer
  ///
  bool is_int(std::string str);

  ///
  /// @return true if string is "nan" (case-insensitive) 
  ///
  bool is_nan(const std::string& s);

  ///
  /// @brief remove leading whitespaces
  ///
  std::string ltrim(std::string str);

  inline bool match_begin(std::string::const_iterator first, 
                          std::string::const_iterator last, 
                          const std::string& str)
  { return (std::distance(first, last)>=static_cast<int>(str.size()) && 
            std::equal(str.begin(), str.end(), first)); 
  }

  inline bool match_end(std::string::const_reverse_iterator first, 
                        std::string::const_reverse_iterator last, 
                        const std::string& str)
  { return (std::distance(first,last)>=static_cast<int>(str.size()) && 
            std::equal(str.rbegin(), str.rend(), first)); 
  }

  ///
  /// Create directory \a dir. The call can fail in many ways, cf. 'man
  /// mkdir'.
  ///
  void mkdir(const std::string& dir);

  ///
  /// @brief Check whether \a path already exists or not.
  ///
  /// @return True if \a path exists, false otherwise.
  ///
  bool node_exist(const std::string& path);

  /**
     @return 0 if \a b = 0 otherwise \f$ \frac{100*a}{b} \f$ 
  */
  int percent(int a, int b);

  ///
  /// @return the current working directory.
  ///
  std::string pwd(void);

  /**
     \return true if first range match second range

     Second range may contain wildcards (such as '*' and '?'), in
     which case vector \a vec is filled with the corresponding strings
     in first range. The algorithm is greedy, i.e., wildcard * is will
     consume as many charcters as possible.

     \note \a vec is supposed to be empty
   */
  bool regexp(std::string::const_iterator first1, 
              std::string::const_iterator end1,
              std::string::const_iterator first2,
              std::string::const_iterator end2,
              std::vector<std::string>& vec);

  /**
     In \a full_str  replace every sub-string \a old_str with
     \a new_str;
   */
  void replace(std::string& full_str, std::string old_str, std::string new_str);

  ///
  /// Search finds a subsecuence in [first, last) being identical to @ str
  ///
  /// @return iterator pointing to first character in found subsequence
  ///
  /// @see std::search
  ///
  inline std::string::iterator search(std::string::iterator first, 
                                      std::string::iterator last, 
                                      std::string str)
  { return std::search(first, last, str.begin(), str.end()); }

  ///
  ///
  ///
  time_t str2time(const std::string&);

  ///
  /// If file does not exist create empty file.
  ///
  void touch(std::string);

  ///
  /// remove leading and trailing whitespaces
  ///
  inline std::string trim(std::string str) { return htrim(ltrim(str)); }


  template <typename T>
  std::string match(std::string::const_iterator& first,
                    const std::string::const_iterator& last,
                    const T& func)
  {
    std::string res;
    for (;first!=last && func(first); ++first) 
      res.append(1,*first);
    return res;
  }


  std::string match(std::string::const_iterator& first,
                    const std::string::const_iterator& last,
                    std::string);

  // template implementations
  template<typename T>
  T convert(const std::string& s)
  {
    if (is_nan(s))
      return std::numeric_limits<T>::quiet_NaN();
    if (is_equal(s, "inf"))
      return std::numeric_limits<T>::infinity();
    if (is_equal(s, "-inf"))
      if (std::numeric_limits<T>::is_signed)
        return -std::numeric_limits<T>::infinity();
      else
        throw std::runtime_error(std::string("convert(\"")+s+
                                 std::string("\"): type is unsigned") );
    std::stringstream ss(s);
    T a;
    ss >> a;
    bool ok = true;
    if(ss.fail()) 
      ok = false;
    // Check that nothing is left on stream
    std::string b;
    ss >> b;
    if (!b.empty() || !ok)
      throw std::runtime_error(std::string("convert(\"")+s+std::string("\")"));
    return a;
  }

}} // end of namespace svndigest end of namespace theplu

#endif