source: trunk/lib/utility.h @ 462

Last change on this file since 462 was 462, checked in by Jari Häkkinen, 14 years ago

Merged patch release 0.6.2 to the trunk. Delta 0.6.2 - 0.6.1

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 8.4 KB
Line 
1#ifndef _theplu_svndigest_utility_
2#define _theplu_svndigest_utility_
3
4// $Id: utility.h 462 2007-08-21 10:34:37Z jari $
5
6/*
7  Copyright (C) 2005, 2006, 2007 Jari Häkkinen, Peter Johansson
8
9  This file is part of svndigest, http://trac.thep.lu.se/trac/svndigest
10
11  svndigest is free software; you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation; either version 2 of the License, or
14  (at your option) any later version.
15
16  svndigest is distributed in the hope that it will be useful, but
17  WITHOUT ANY WARRANTY; without even the implied warranty of
18  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  General Public License for more details.
20
21  You should have received a copy of the GNU General Public License
22  along with this program; if not, write to the Free Software
23  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
24  02111-1307, USA.
25*/
26
27#include <algorithm>
28#include <functional>
29#include <iosfwd>
30#include <string>
31#include <utility>
32#include <vector>
33
34#include <sys/stat.h>
35
36namespace theplu{
37namespace svndigest{
38
39  ///
40  /// @brief Check if access permissions match \a mode. \a mode must
41  /// be given as r, w, x, or combinations of these letters.
42  ///
43  /// @return On success (all requested permissions granted), zero
44  /// is returned. On error (at least one bit in mode asked for a
45  /// permission that is denied, or some other error occurred), -1
46  /// is returned, and errno is set appropriately.
47  ///
48  /// @throw An std::runtime_error is thrown when checking for write
49  /// permissions for a file/direcotry that does not exist.
50  ///
51  /// @see access(2)
52  ///
53  int access_rights(const std::string& path,const std::string& bits);
54
55  /**
56     @brief Copy file \a source to \a target.
57
58     @throw std::runtime_error when read error of \a source or write
59     error for \a target is encountered.
60  */
61  void copy_file(const std::string& source, const std::string& target);
62
63  ///
64  /// @return everything after last '/'
65  ///
66  std::string file_name(const std::string&);
67
68  ///
69  /// @brief environment variable @a var
70  ///
71  std::string getenv(const std::string& var); 
72
73  ///
74  /// If @a width is set, size is forced to length @a width. This
75  /// implies, e.g., that hex(15,2) and hex(17,1) return "0F" and "1",
76  /// respectively.
77  ///
78  /// @return x in hexadecimal base
79  ///
80  std::string hex(int x, u_int width=0);
81
82  ///
83  /// @brief remove trailing whitespaces
84  ///
85  std::string htrim(std::string str);
86
87  ///
88  /// @return true if \a str is an integer
89  ///
90  bool is_int(std::string str);
91
92  ///
93  /// @brief remove leading whitespaces
94  ///
95  std::string ltrim(std::string str);
96
97  inline bool match_begin(std::string::const_iterator first, 
98                          std::string::const_iterator last, 
99                          const std::string& str)
100  { return (std::distance(first, last)>=static_cast<int>(str.size()) && 
101            std::equal(str.begin(), str.end(), first)); 
102  }
103
104  inline bool match_end(std::string::const_reverse_iterator first, 
105                        std::string::const_reverse_iterator last, 
106                        const std::string& str)
107  { return (std::distance(first,last)>=static_cast<int>(str.size()) && 
108            std::equal(str.rbegin(), str.rend(), first)); 
109  }
110
111  ///
112  /// Create directory \a dir. The call can fail in many ways, cf. 'man
113  /// mkdir'.
114  ///
115  inline int mkdir(const std::string& dir) { return ::mkdir(dir.c_str(),0777); }
116
117  ///
118  /// @brief Check whether \a path already exists or not.
119  ///
120  /// @return True if \a path exists, false otherwise.
121  ///
122  bool node_exist(const std::string& path);
123
124  /**
125     @return 0 if \a b = 0 otherwise \f$ \frac{100*a}{b} \f$
126  */
127  int percent(int a, int b);
128
129  ///
130  /// @return the current working directory.
131  ///
132  std::string pwd(void);
133
134  ///
135  /// Search finds a subsecuence in [first, last) being identical to @ str
136  ///
137  /// @return iterator pointing to first character in found subsequence
138  ///
139  /// @see std::search
140  ///
141  inline std::string::iterator search(std::string::iterator first, 
142                                      std::string::iterator last, 
143                                      std::string str)
144  { return std::search(first, last, str.begin(), str.end()); }
145
146  ///
147  ///
148  ///
149  time_t str2time(const std::string&);
150
151  ///
152  /// If file does not exist create empty file.
153  ///
154  void touch(std::string);
155
156  ///
157  /// remove leading and trailing whitespaces
158  ///
159  inline std::string trim(std::string str) { return htrim(ltrim(str)); }
160
161
162  template <typename T>
163  std::string match(std::string::const_iterator& first,
164                    const std::string::const_iterator& last,
165                    const T& func)
166  {
167    std::string res;
168    for (;first!=last && func(first); ++first) 
169      res.append(1,*first);
170    return res;
171  }
172
173
174  std::string match(std::string::const_iterator& first,
175                    const std::string::const_iterator& last,
176                    std::string);
177
178  struct AlNum
179  {
180    inline bool operator()(std::string::const_iterator i) const 
181    { return isalnum(*i); }
182  };
183
184
185  struct Digit
186  {
187    inline bool operator()(std::string::const_iterator i) const 
188    { return isdigit(*i); }
189  };
190
191
192  class notChar
193  {
194  public:
195    notChar(char);
196    inline bool operator()(std::string::const_iterator i) const 
197    { return *i!=char_; }
198  private:
199    char char_;
200  };
201
202
203  class not2Char
204  {
205  public:
206    not2Char(char, char);
207    inline bool operator()(std::string::const_iterator i) const 
208    { return *i!=char1_ && *i!=char2_; }
209  private:
210    const char char1_;
211    const char char2_;
212  };
213
214  class not2Str
215  {
216  public:
217    not2Str(std::string, std::string);
218    inline bool operator()(std::string::const_iterator i) const 
219    { 
220      return !(std::equal(str1_.begin(), str1_.end(), i) ||
221              std::equal(str2_.begin(), str2_.end(), i));
222    } 
223
224  private:
225    const std::string str1_;
226    const std::string str2_;
227  };
228
229  ///
230  /// Functor to be used on contaioners and works as standard less,
231  /// but on the reversed container.
232  ///
233  /// Requirements on T is that has rend and rbegin. T::value_type
234  /// must be comparable (i.e. have operator<)
235  ///
236  template <typename T>
237  struct LessReversed
238  {
239    ///
240    /// using std::lexicographical_compare on the reversed container
241    ///
242    inline bool operator()(const T& x, const T& y) const
243    { return std::lexicographical_compare(x.rbegin(),x.rend(),
244                                          y.rbegin(),y.rend()); }
245  };
246
247
248  ///
249  /// @brief Functor comparing pairs using second.
250  ///
251  /// STL provides operator< for the pair.first element, but none for
252  /// pair.second. This template provides this and can be used as the
253  /// comparison object in generic functions such as the STL sort.
254  ///
255  template <typename T1, typename T2>
256  struct pair_value_compare
257  {
258    ///
259    /// @return true if x.second<y.second or (x.second==y.second and
260    /// x.first<y.first)
261    ///
262    inline bool operator()(const std::pair<T1,T2>& x,
263                           const std::pair<T1,T2>& y) {
264      return ((x.second<y.second) ||
265              (!(y.second<x.second) && (x.first<y.first))); 
266    }
267  };
268
269 
270  ///
271  /// Functor working on pair.second, using a user passed functor.
272  ///
273  template <typename T1, typename T2, typename T3>
274  struct PairSecondCompare
275  {
276
277    ///
278    /// @brief Constructor
279    ///
280    explicit PairSecondCompare(const T3& comp)
281      : compare_(comp) {}
282
283    ///
284    /// @return compare(x.second, y.second) where compare is a
285    /// internal comparison functor.
286    ///
287    inline bool operator()(const std::pair<T1,T2>& x,
288                           const std::pair<T1,T2>& y) const
289    { return compare_(x.second,y.second); }
290
291  private:
292    T3 compare_;
293
294  };
295 
296  ///
297  /// Calculating sum of two vectors.
298  ///
299  /// @return resulting vector
300  ///
301  template <typename T >
302  struct VectorPlus : 
303    public std::binary_function<std::vector<T>,std::vector<T>,std::vector<T> >
304  {
305    std::vector<T> operator()(const std::vector<T>& u,
306                              const std::vector<T>& v) const 
307    {
308      if ( u.size() > v.size() ){
309        std::vector<T> res(u.size());
310        transform(u.begin(), u.end(), v.begin(), res.begin(), std::plus<T>());
311        copy(u.begin()+v.size(), u.end(), res.begin()+v.size());
312        return res;
313      }
314 
315      std::vector<T> res(v.size());
316      transform(v.begin(), v.end(), u.begin(), res.begin(), std::plus<T>());
317      if ( v.size() > u.size() )
318        copy(v.begin()+u.size(), v.end(), res.begin()+u.size());
319      return res;
320    }
321
322  };
323
324  ///
325  /// @return resulting vector
326  ///
327  template <typename Key, typename T>
328  struct PairValuePlus :
329    public std::binary_function<std::vector<T>,
330                                std::pair<const Key, std::vector<T> >, 
331                                std::vector<T> >
332  {
333    std::vector<T> operator()(const std::vector<T>& sum, 
334                              const std::pair<const Key,std::vector<T> >& p)
335    {
336      return VectorPlus<T>()(sum, p.second);
337    }
338  };
339
340}} // end of namespace svndigest end of namespace theplu
341
342#endif
Note: See TracBrowser for help on using the repository browser.