ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/utils/Trim.hpp
(Generate patch)

Comparing trunk/OOPSE-4/src/utils/Trim.hpp (file contents):
Revision 2211 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 2212 by tim, Fri Apr 22 21:52:51 2005 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. Acknowledgement of the program authors must be made in any
10 < *    publication of scientific results based in part on use of the
11 < *    program.  An acceptable form of acknowledgement is citation of
12 < *    the article in which the program was described (Matthew
13 < *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 < *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 < *    Parallel Simulation Engine for Molecular Dynamics,"
16 < *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 < *
18 < * 2. Redistributions of source code must retain the above copyright
19 < *    notice, this list of conditions and the following disclaimer.
20 < *
21 < * 3. Redistributions in binary form must reproduce the above copyright
22 < *    notice, this list of conditions and the following disclaimer in the
23 < *    documentation and/or other materials provided with the
24 < *    distribution.
25 < *
26 < * This software is provided "AS IS," without a warranty of any
27 < * kind. All express or implied conditions, representations and
28 < * warranties, including any implied warranty of merchantability,
29 < * fitness for a particular purpose or non-infringement, are hereby
30 < * excluded.  The University of Notre Dame and its licensors shall not
31 < * be liable for any damages suffered by licensee as a result of
32 < * using, modifying or distributing the software or its
33 < * derivatives. In no event will the University of Notre Dame or its
34 < * licensors be liable for any lost revenue, profit or data, or for
35 < * direct, indirect, special, consequential, incidental or punitive
36 < * damages, however caused and regardless of the theory of liability,
37 < * arising out of the use of or inability to use software, even if the
38 < * University of Notre Dame has been advised of the possibility of
39 < * such damages.
40 < */
41 <
42 < #ifndef UTILS_TRIM_HPP
43 < #define UTILS_TRIM_HPP
44 <
45 < #include <string>
46 < #include <cctype>
47 <
48 < /**
49 < * @file Trim.hpp
50 < * Defines trim algorithms. Trim algorithms are used to remove trailing and leading spaces from a string.
51 < */
52 < namespace oopse {
53 <
54 <  /**
55 <   * Remove all leading spaces in-place. The supplied predicate is used to determine which
56 <   * characters are considered spaces
57 <   * @param str An input sequence
58 <   * @param IsSpace An unary predicate identifying spaces
59 <   */
60 <  template<typename Predict>    
61 <  void trimLeftIf(std::string& str, Predict isSpace) {
62 <    std::string::iterator i = str.begin();
63 <
64 <    for (; i != str.end(); ++i) {
65 <      if (!isSpace(*i)) {
66 <        break;
67 <      }
68 <    }
69 <        
70 <    str.erase(str.begin(), i);
71 <  }
72 <
73 <  /**
74 <   * Remove all trailing spaces in-place. The supplied predicate is used to determine which
75 <   * characters are considered spaces
76 <   * @param str An input sequence
77 <   */
78 <  template<typename Predict>    
79 <  void trimRightIf(std::string& str, Predict isSpace) {
80 <    std::string::iterator i = str.end();
81 <
82 <    for (; i != str.begin();) {
83 <      if (!isSpace(*(--i))) {
84 <        ++i;
85 <        break;
86 <      }
87 <    }
88 <        
89 <    str.erase(i, str.end());
90 <  }
91 <
92 <  /**
93 <   *Remove all leading and trailing spaces in-place. The supplied predicate is used to determine
94 <   * which characters are considered spaces
95 <   * @param str An input sequence
96 <   */
97 <  template<typename Predict>    
98 <  void trimIf(std::string& str, Predict isSpace) {
99 <    trimLeftIf(str, isSpace);
100 <    trimRightIf(str, isSpace);        
101 <  }
102 <
103 <  /**
104 <   * Remove all leading spaces from the input. The supplied predicate is used to determine
105 <   * which characters are considered spaces
106 <   * @return A trimmed copy of the input
107 <   * @param input An input sequence
108 <   */
109 <  template<typename Predict>
110 <  std::string trimLeftCopyIf(const std::string& input, Predict isSpace) {
111 <    std::string result(input);
112 <    trimLeftIf(result, isSpace);
113 <    return result;
114 <  }
115 <
116 <  /**
117 <   * Remove all trailing spaces from the input. The supplied predicate is used to determine
118 <   * which characters are considered spaces
119 <   * @return A trimmed copy of the input
120 <   * @param input An input sequence
121 <   */
122 <  template<typename Predict>
123 <  std::string trimRightCopyIf(const std::string& input, Predict isSpace) {
124 <    std::string result(input);
125 <    trimRightIf(result, isSpace);
126 <    return result;
127 <  }
128 <
129 <  /**
130 <   * Remove all leading and trailing spaces from the input. The supplied predicate is used to
131 <   * determine which characters are considered spaces
132 <   * @return A trimmed copy of the input
133 <   * @param input An input sequence
134 <   */
135 <  template<typename Predict>    
136 <  std::string trimCopyIf(const std::string& input, Predict isSpace) {
137 <    std::string result(input);
138 <    trimIf(result, isSpace);
139 <    return result;
140 <  }
141 <
142 <    
143 <  /**
144 <   * Remove all leading spaces in-place.
145 <   * @param str An input sequence
146 <   */
147 <  void trimLeft(std::string& str);
148 <
149 <  /**
150 <   * Remove all trailing spaces in-place.
151 <   * @param str An input sequence
152 <   */
153 <  void trimRight(std::string& str);
154 <
155 <  /**
156 <   *Remove all leading and trailing spaces in-place
157 <   * @param str An input sequence
158 <   */
159 <  void trim(std::string& str);
160 <
161 <  /**
162 <   * Remove all leading spaces from the input.
163 <   * @return A trimmed copy of the input
164 <   * @param input An input sequence
165 <   */
166 <  std::string trimLeftCopy(const std::string& input);
167 <
168 <  /**
169 <   * Remove all trailing spaces from the input.
170 <   * @return A trimmed copy of the input
171 <   * @param input An input sequence
172 <   */
173 <  std::string trimRightCopy(const std::string& input);
174 <
175 <  /**
176 <   *Remove all leading and trailing spaces from the input.
177 <   * @return A trimmed copy of the input
178 <   * @param input An input sequence
179 <   */
180 <  std::string trimCopy(const std::string& input);
181 <
182 < }//end namespace oopse
183 < #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. Acknowledgement of the program authors must be made in any
10 > *    publication of scientific results based in part on use of the
11 > *    program.  An acceptable form of acknowledgement is citation of
12 > *    the article in which the program was described (Matthew
13 > *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 > *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 > *    Parallel Simulation Engine for Molecular Dynamics,"
16 > *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 > *
18 > * 2. Redistributions of source code must retain the above copyright
19 > *    notice, this list of conditions and the following disclaimer.
20 > *
21 > * 3. Redistributions in binary form must reproduce the above copyright
22 > *    notice, this list of conditions and the following disclaimer in the
23 > *    documentation and/or other materials provided with the
24 > *    distribution.
25 > *
26 > * This software is provided "AS IS," without a warranty of any
27 > * kind. All express or implied conditions, representations and
28 > * warranties, including any implied warranty of merchantability,
29 > * fitness for a particular purpose or non-infringement, are hereby
30 > * excluded.  The University of Notre Dame and its licensors shall not
31 > * be liable for any damages suffered by licensee as a result of
32 > * using, modifying or distributing the software or its
33 > * derivatives. In no event will the University of Notre Dame or its
34 > * licensors be liable for any lost revenue, profit or data, or for
35 > * direct, indirect, special, consequential, incidental or punitive
36 > * damages, however caused and regardless of the theory of liability,
37 > * arising out of the use of or inability to use software, even if the
38 > * University of Notre Dame has been advised of the possibility of
39 > * such damages.
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 oopse {
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 oopse
191 > #endif //UTILS_TRIM_HPP    

Diff Legend

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