source: trunk/lib/utility.h @ 118

// $Id: utility.h 118 2006-07-03 07:44:49Z peter $

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

  This file is part of svnstat, http://lev.thep.lu.se/trac/svnstat

  svnstat 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.

  svnstat 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.
*/

#ifndef _theplu_svnstat_utility_
#define _theplu_svnstat_utility_

#include <algorithm>
#include <fstream>
#include <functional>
#include <map>
#include <string>
#include <utility>
#include <vector>

namespace theplu{
namespace svnstat{

  ///
  /// @return 0 if ok
  /// 
  int blame(const std::string&);
  
  ///
  /// Create directory \a dir. The call can fail in many ways, cf. 'man
  /// mkdir'. If the \a dir exists, setting \a force to true will
  /// trigger a recursive removal of the target \a dir.
  ///
  int createdir(const std::string& dir, bool force=false);

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

  ///
  /// Extracts information from 'svn info <node>'
  ///
  /// @note <node> must be in subversion control.
  ///
  std::map<std::string, std::string> info(const std::string&);

  ///
  /// stupid function needed for systems calls to be correct for
  /// filenames containing spaces.
  /// @note this function will be removed.
  ///
  /// @return passed string with ' ' changed to '\ '
  ///
  std::string mod_str(const std::string&);

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

  ///
  /// @printing cascading style sheet to stream @a s.
  ///
  void print_css(std::ostream& s);

  inline bool match_begin(std::string::iterator first, 
                          std::string::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::iterator first, 
                        std::string::iterator last, 
                        const std::string& str)
  { return (std::distance(first,last)>=static_cast<int>(str.size()) && 
            std::equal(str.rbegin(), str.rend(), first)); 
  }

  inline std::string::iterator search(std::string::iterator& first, 
                                      std::string::iterator& last, 
                                      const std::string& str)
  { return std::search(first, last, str.begin(), str.end()); }

  ///
  /// Calculating sum of two vectors.
  ///
  /// @return resulting vector
  ///
  template <typename T >
  struct VectorPlus : 
    public std::binary_function<std::vector<T>,std::vector<T>,std::vector<T> >
  {
    std::vector<T> operator()(const std::vector<T>& u,
                              const std::vector<T>& v) const 
    {
      if ( u.size() > v.size() ){
        std::vector<T> res(u.size());
        transform(u.begin(), u.end(), v.begin(), res.begin(), std::plus<T>());
        copy(u.begin()+v.size(), u.end(), res.begin()+v.size());
        return res;
      }
  
      std::vector<T> res(v.size());
      transform(v.begin(), v.end(), u.begin(), res.begin(), std::plus<T>());
      if ( v.size() > u.size() )
        copy(v.begin()+u.size(), v.end(), res.begin()+u.size());
      return res;
    }

  };

  ///
  /// @return resulting vector
  ///
  template <typename Key, typename T>
  struct PairValuePlus :
    public std::binary_function<std::vector<T>,
                                std::pair<const Key, std::vector<T> >, 
                                std::vector<T> >
  {
    std::vector<T> operator()(const std::vector<T>& sum, 
                              const std::pair<const Key,std::vector<T> >& p)
    {
      return VectorPlus<T>()(sum, p.second);
    }
  };

  ///
  /// Jari, is this obsolete? And thus erasable?
  ///
  struct CodingMore :
    public std::binary_function<std::pair<std::string,std::vector<u_int> >,
                                std::pair<std::string,std::vector<u_int> >,
                                bool >
  {
    inline bool operator()
      (const std::pair<std::string,std::vector<u_int> >& a, 
       const std::pair<std::string,std::vector<u_int> >& b)
    {
      if (a.second.back() > b.second.back())
        return true;
      else if (a.second.back() < b.second.back())
        return false;
      return a.first < b.first;
    }
  };

}}

// end of namespace svnstat end of namespace theplu
#endif