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 2203 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
Revision 2204 by gezelter, Fri Apr 15 22:04:00 2005 UTC

# Line 1 | Line 1
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
# Line 51 | Line 51 | namespace oopse {
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();
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);
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();
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());
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 <    }
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 <    }
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 <    }
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 <    }
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);
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);
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);
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);
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);
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);
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    

Diff Legend

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