ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/utils/Trim.hpp
(Generate patch)

Comparing branches/development/src/utils/Trim.hpp (file contents):
Revision 1665 by gezelter, Tue Nov 22 20:38:56 2011 UTC vs.
Revision 1808 by gezelter, Mon Oct 22 20:42:10 2012 UTC

# Line 1 | Line 1
1 < /*
2 < * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 < *
4 < * The University of Notre Dame grants you ("Licensee") a
5 < * non-exclusive, royalty free, license to use, modify and
6 < * redistribute this software in source and binary code form, provided
7 < * that the following conditions are met:
8 < *
9 < * 1. Redistributions of source code must retain the above copyright
10 < *    notice, this list of conditions and the following disclaimer.
11 < *
12 < * 2. Redistributions in binary form must reproduce the above copyright
13 < *    notice, this list of conditions and the following disclaimer in the
14 < *    documentation and/or other materials provided with the
15 < *    distribution.
16 < *
17 < * This software is provided "AS IS," without a warranty of any
18 < * kind. All express or implied conditions, representations and
19 < * warranties, including any implied warranty of merchantability,
20 < * fitness for a particular purpose or non-infringement, are hereby
21 < * excluded.  The University of Notre Dame and its licensors shall not
22 < * be liable for any damages suffered by licensee as a result of
23 < * using, modifying or distributing the software or its
24 < * derivatives. In no event will the University of Notre Dame or its
25 < * licensors be liable for any lost revenue, profit or data, or for
26 < * direct, indirect, special, consequential, incidental or punitive
27 < * damages, however caused and regardless of the theory of liability,
28 < * arising out of the use of or inability to use software, even if the
29 < * University of Notre Dame has been advised of the possibility of
30 < * such damages.
31 < *
32 < * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 < * research, please cite the appropriate papers when you publish your
34 < * work.  Good starting points are:
35 < *                                                                      
36 < * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 < * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 < * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 < * [4]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).                        
40 < */
41 <
42 < #ifndef UTILS_TRIM_HPP
43 < #define UTILS_TRIM_HPP
44 <
45 < #include <string>
46 < #include <cctype>
47 < #include "utils/Predicate.hpp"
48 <
49 < /**
50 < * @file Trim.hpp
51 < * Defines trim algorithms. Trim algorithms are used to remove trailing and leading spaces from a string.
52 < */
53 < namespace OpenMD {
54 <
55 <  /**
56 <   * Remove all leading spaces in-place. The supplied predicate is used to determine which
57 <   * characters are considered spaces
58 <   * @param str An input sequence
59 <   * @param IsSpace An unary predicate identifying spaces
60 <   *
61 <   * @code
62 <   * std::string str = "  acb  trimLeftIf test case"
63 <   * trimLeftIf(str, pred() || isFromRange('a', 'c'));
64 <   * std::cout << str << std::endl; //print "trimLeft test case"
65 <   *
66 <   * @endcode
67 <   */
68 <  template<typename Predict>    
69 <  void trimLeftIf(std::string& str, Predict pred) {
70 <    std::string::iterator i = str.begin();
71 <
72 <    for (; i != str.end(); ++i) {
73 <      if (!pred(*i)) {
74 <        break;
75 <      }
76 <    }
77 <        
78 <    str.erase(str.begin(), i);
79 <  }
80 <
81 <  /**
82 <   * Remove all trailing spaces in-place. The supplied predicate is used to determine which
83 <   * characters are considered spaces
84 <   * @param str An input sequence
85 <   */
86 <  template<typename Predict>    
87 <  void trimRightIf(std::string& str, Predict pred) {
88 <    std::string::iterator i = str.end();
89 <
90 <    for (; i != str.begin();) {
91 <      if (!pred(*(--i))) {
92 <        ++i;
93 <        break;
94 <      }
95 <    }
96 <        
97 <    str.erase(i, str.end());
98 <  }
99 <
100 <  /**
101 <   *Remove all leading and trailing spaces in-place. The supplied predicate is used to determine
102 <   * which characters are considered spaces
103 <   * @param str An input sequence
104 <   */
105 <  template<typename Predict>    
106 <  void trimIf(std::string& str, Predict pred) {
107 <    trimLeftIf(str, pred);
108 <    trimRightIf(str, pred);        
109 <  }
110 <
111 <  /**
112 <   * Remove all leading spaces from the input. The supplied predicate is used to determine
113 <   * which characters are considered spaces
114 <   * @return A trimmed copy of the input
115 <   * @param input An input sequence
116 <   */
117 <  template<typename Predict>
118 <  std::string trimLeftCopyIf(const std::string& input, Predict pred) {
119 <    std::string result(input);
120 <    trimLeftIf(result, pred);
121 <    return result;
122 <  }
123 <
124 <  /**
125 <   * Remove all trailing spaces from the input. The supplied predicate is used to determine
126 <   * which characters are considered spaces
127 <   * @return A trimmed copy of the input
128 <   * @param input An input sequence
129 <   */
130 <  template<typename Predict>
131 <  std::string trimRightCopyIf(const std::string& input, Predict pred) {
132 <    std::string result(input);
133 <    trimRightIf(result, pred);
134 <    return result;
135 <  }
136 <
137 <  /**
138 <   * Remove all leading and trailing spaces from the input. The supplied predicate is used to
139 <   * determine which characters are considered spaces
140 <   * @return A trimmed copy of the input
141 <   * @param input An input sequence
142 <   */
143 <  template<typename Predict>    
144 <  std::string trimCopyIf(const std::string& input, Predict pred) {
145 <    std::string result(input);
146 <    trimIf(result, pred);
147 <    return result;
148 <  }
149 <
150 <    
151 <  /**
152 <   * Remove all leading spaces in-place.
153 <   * @param str An input sequence
154 <   */
155 <  void trimLeft(std::string& str);
156 <
157 <  /**
158 <   * Remove all trailing spaces in-place.
159 <   * @param str An input sequence
160 <   */
161 <  void trimRight(std::string& str);
162 <
163 <  /**
164 <   *Remove all leading and trailing spaces in-place
165 <   * @param str An input sequence
166 <   */
167 <  void trim(std::string& str);
168 <
169 <  /**
170 <   * Remove all leading spaces from the input.
171 <   * @return A trimmed copy of the input
172 <   * @param input An input sequence
173 <   */
174 <  std::string trimLeftCopy(const std::string& input);
175 <
176 <  /**
177 <   * Remove all trailing spaces from the input.
178 <   * @return A trimmed copy of the input
179 <   * @param input An input sequence
180 <   */
181 <  std::string trimRightCopy(const std::string& input);
182 <
183 <  /**
184 <   *Remove all leading and trailing spaces from the input.
185 <   * @return A trimmed copy of the input
186 <   * @param input An input sequence
187 <   */
188 <  std::string trimCopy(const std::string& input);
189 <
190 < }//end namespace OpenMD
191 < #endif //UTILS_TRIM_HPP    
1 > /*
2 > * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 > *
4 > * The University of Notre Dame grants you ("Licensee") a
5 > * non-exclusive, royalty free, license to use, modify and
6 > * redistribute this software in source and binary code form, provided
7 > * that the following conditions are met:
8 > *
9 > * 1. Redistributions of source code must retain the above copyright
10 > *    notice, this list of conditions and the following disclaimer.
11 > *
12 > * 2. Redistributions in binary form must reproduce the above copyright
13 > *    notice, this list of conditions and the following disclaimer in the
14 > *    documentation and/or other materials provided with the
15 > *    distribution.
16 > *
17 > * This software is provided "AS IS," without a warranty of any
18 > * kind. All express or implied conditions, representations and
19 > * warranties, including any implied warranty of merchantability,
20 > * fitness for a particular purpose or non-infringement, are hereby
21 > * excluded.  The University of Notre Dame and its licensors shall not
22 > * be liable for any damages suffered by licensee as a result of
23 > * using, modifying or distributing the software or its
24 > * derivatives. In no event will the University of Notre Dame or its
25 > * licensors be liable for any lost revenue, profit or data, or for
26 > * direct, indirect, special, consequential, incidental or punitive
27 > * damages, however caused and regardless of the theory of liability,
28 > * arising out of the use of or inability to use software, even if the
29 > * University of Notre Dame has been advised of the possibility of
30 > * such damages.
31 > *
32 > * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 > * research, please cite the appropriate papers when you publish your
34 > * work.  Good starting points are:
35 > *                                                                      
36 > * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 > * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 > * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 > * [4]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).                        
40 > */
41 >
42 > #ifndef UTILS_TRIM_HPP
43 > #define UTILS_TRIM_HPP
44 >
45 > #include <string>
46 > #include <cctype>
47 > #include "utils/Predicate.hpp"
48 >
49 > /**
50 > * @file Trim.hpp
51 > * Defines trim algorithms. Trim algorithms are used to remove trailing and leading spaces from a string.
52 > */
53 > namespace OpenMD {
54 >
55 >  /**
56 >   * Remove all leading spaces in-place. The supplied predicate is used to determine which
57 >   * characters are considered spaces
58 >   * @param str An input sequence
59 >   * @param pred The unary predicate identifying spaces
60 >   *
61 >   * @code
62 >   * std::string str = "  acb  trimLeftIf test case"
63 >   * trimLeftIf(str, pred() || isFromRange('a', 'c'));
64 >   * std::cout << str << std::endl; //print "trimLeft test case"
65 >   *
66 >   * @endcode
67 >   */
68 >  template<typename P>    
69 >  void trimLeftIf(std::string& str, P pred) {
70 >    std::string::iterator i = str.begin();
71 >
72 >    for (; i != str.end(); ++i) {
73 >      if (!pred(*i)) {
74 >        break;
75 >      }
76 >    }
77 >        
78 >    str.erase(str.begin(), i);
79 >  }
80 >
81 >  /**
82 >   * Remove all trailing spaces in-place. The supplied predicate is used to determine which
83 >   * characters are considered spaces
84 >   * @param str An input sequence
85 >   * @param pred The unary predicate identifying spaces
86 >   */
87 >  template<typename P>    
88 >  void trimRightIf(std::string& str, P pred) {
89 >    std::string::iterator i = str.end();
90 >
91 >    for (; i != str.begin();) {
92 >      if (!pred(*(--i))) {
93 >        ++i;
94 >        break;
95 >      }
96 >    }
97 >        
98 >    str.erase(i, str.end());
99 >  }
100 >
101 >  /**
102 >   *Remove all leading and trailing spaces in-place. The supplied predicate is used to determine
103 >   * which characters are considered spaces
104 >   * @param str An input sequence
105 >   * @param pred The unary predicate identifying spaces
106 >   */
107 >  template<typename P>    
108 >  void trimIf(std::string& str, P pred) {
109 >    trimLeftIf(str, pred);
110 >    trimRightIf(str, pred);        
111 >  }
112 >
113 >  /**
114 >   * Remove all leading spaces from the input. The supplied predicate is used to determine
115 >   * which characters are considered spaces
116 >   * @return A trimmed copy of the input
117 >   * @param input An input sequence
118 >   * @param pred The unary predicate identifying spaces
119 >   */
120 >  template<typename P>
121 >  std::string trimLeftCopyIf(const std::string& input, P pred) {
122 >    std::string result(input);
123 >    trimLeftIf(result, pred);
124 >    return result;
125 >  }
126 >
127 >  /**
128 >   * Remove all trailing spaces from the input. The supplied predicate is used to determine
129 >   * which characters are considered spaces
130 >   * @return A trimmed copy of the input
131 >   * @param input An input sequence
132 >   * @param pred The unary predicate identifying spaces
133 >   */
134 >  template<typename P>
135 >  std::string trimRightCopyIf(const std::string& input, P pred) {
136 >    std::string result(input);
137 >    trimRightIf(result, pred);
138 >    return result;
139 >  }
140 >
141 >  /**
142 >   * Remove all leading and trailing spaces from the input. The supplied predicate is used to
143 >   * determine which characters are considered spaces
144 >   * @return A trimmed copy of the input
145 >   * @param input An input sequence
146 >   * @param pred The unary predicate identifying spaces
147 >   */
148 >  template<typename P>    
149 >  std::string trimCopyIf(const std::string& input, P pred) {
150 >    std::string result(input);
151 >    trimIf(result, pred);
152 >    return result;
153 >  }
154 >
155 >    
156 >  /**
157 >   * Remove all leading spaces in-place.
158 >   * @param str An input sequence
159 >   */
160 >  void trimLeft(std::string& str);
161 >
162 >  /**
163 >   * Remove all trailing spaces in-place.
164 >   * @param str An input sequence
165 >   */
166 >  void trimRight(std::string& str);
167 >
168 >  /**
169 >   *Remove all leading and trailing spaces in-place
170 >   * @param str An input sequence
171 >   */
172 >  void trim(std::string& str);
173 >
174 >  /**
175 >   * Remove all leading spaces from the input.
176 >   * @return A trimmed copy of the input
177 >   * @param input An input sequence
178 >   */
179 >  std::string trimLeftCopy(const std::string& input);
180 >
181 >  /**
182 >   * Remove all trailing spaces from the input.
183 >   * @return A trimmed copy of the input
184 >   * @param input An input sequence
185 >   */
186 >  std::string trimRightCopy(const std::string& input);
187 >
188 >  /**
189 >   *Remove all leading and trailing spaces from the input.
190 >   * @return A trimmed copy of the input
191 >   * @param input An input sequence
192 >   */
193 >  std::string trimCopy(const std::string& input);
194 >
195 > }//end namespace OpenMD
196 > #endif //UTILS_TRIM_HPP    

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines