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

Comparing trunk/OOPSE-4/src/utils/StringUtils.cpp (file contents):
Revision 1590 by gezelter, Mon Oct 18 16:29:53 2004 UTC vs.
Revision 2982 by tim, Wed Aug 30 18:42:29 2006 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 + #include <algorithm>
43   #include "utils/StringUtils.hpp"
44  
45 < using namespace std;
46 < using namespace oopse;
47 <
48 < string UpperCase(const string& S) {
49 <  string uc = S;
50 <  unsigned int n = uc.size();
51 <  for (unsigned int j = 0; j < n; j++) {  
52 <    char sj = uc[j];
53 <    if (sj >= 'a' && sj <= 'z') uc[j] = (char)(sj - ('a' - 'A'));
45 > namespace oopse {
46 >  std::string UpperCase(const std::string& S) {
47 >    std::string uc = S;
48 >    unsigned int n = uc.size();
49 >    for (unsigned int j = 0; j < n; j++) {  
50 >      char sj = uc[j];
51 >      if (sj >= 'a' && sj <= 'z') uc[j] = (char)(sj - ('a' - 'A'));
52 >    }
53 >    return uc;
54    }
13 –  return uc;
14 – }
55  
56 < string LowerCase(const string& S) {
57 <  string lc = S;
58 <  unsigned int n = lc.size();
59 <  for (unsigned int j = 0; j < n; j++) {
60 <    char sj = lc[j];
61 <    if (sj >= 'A' && sj <= 'Z') lc[j] = (char)(sj + ('a' - 'A'));
56 >  std::string LowerCase(const std::string& S) {
57 >    std::string lc = S;
58 >    unsigned int n = lc.size();
59 >    for (unsigned int j = 0; j < n; j++) {
60 >      char sj = lc[j];
61 >      if (sj >= 'A' && sj <= 'Z') lc[j] = (char)(sj + ('a' - 'A'));
62 >    }
63 >    return lc;
64    }
23 –  return lc;
24 – }
65  
66 < int findBegin(istream theStream, char* startText ){
67 <  const int MAXLEN = 1024;
68 <  char readLine[MAXLEN];  
29 <  int foundText = 0;
30 <  int lineNum;
31 <  char* the_token;
32 <  char* eof_test;
66 >  char* trimSpaces(char *str) {
67 >    size_t len;
68 >    char *right, *left;
69  
70 <  // rewind the stream
35 <  theStream.seekg (0, ios::beg);
36 <  lineNum = 0;
70 >    if (strlen(str) == 0) return(str);
71    
72 <  if (!theStream.eof()) {
73 <    theStream.getline(readLine, MAXLEN);
74 <    lineNum++;
75 <  } else {
76 <    printf( "Error fast forwarding stream: stream is empty.\n");
77 <    return -1;
72 >    /* Trim whitespace from left side */
73 >    for (left = str; isspace(*left); left++);
74 >
75 >    /* Trim whitespace from right side */
76 >    if ((len = strlen(left)))
77 >      {
78 >        right = left + (len - 1);
79 >      
80 >        while (isspace(*right))
81 >          {
82 >            *right = '\0';
83 >            right--;
84 >          }
85 >      }
86 >
87 >    /* Only do the str copy if there were spaces to the left */
88 >    if (left != str)
89 >      strcpy(str, left);
90 >  
91 >    return (str);
92    }
93 +
94 +  int findBegin(std::istream &theStream, char* startText ){
95 +    const int MAXLEN = 1024;
96 +    char readLine[MAXLEN];  
97 +    int foundText = 0;
98 +    int lineNum;
99 +    char* the_token;
100 +    char* eof_test;
101 +
102 +    // rewind the stream
103 +    theStream.seekg (0, std::ios::beg);
104 +    lineNum = 0;
105    
106 <  while ( !foundText ) {
107 <    
108 <    if (theStream.eof()) {
109 <      printf("Error fast forwarding stream at line %d: "
110 <             "stream ended unexpectedly.\n", lineNum);
106 >    if (!theStream.eof()) {
107 >      theStream.getline(readLine, MAXLEN);
108 >      lineNum++;
109 >    } else {
110 >      printf( "Error fast forwarding stream: stream is empty.\n");
111        return -1;
112      }
113 <
114 <    the_token = strtok( readLine, " ,;\t" );
115 <
116 <    if (!strcasecmp("begin", the_token)) {
117 <      the_token = TrimSpaces(strtok( NULL, " ,;\t" ));
118 <      foundText = !strcasecmp( startText, the_token );
59 <    }
60 <
61 <    if (!foundText) {
62 <      if (!theStream.eof()) {
63 <        theStream.getline(readLine, MAXLEN);
64 <        lineNum++;
65 <      } else {
66 <        printf( "Error fast forwarding stream at line %d: "
67 <                "stream ended unexpectedly.\n", lineNum);
113 >  
114 >    while ( !foundText ) {
115 >    
116 >      if (theStream.eof()) {
117 >        printf("Error fast forwarding stream at line %d: "
118 >               "stream ended unexpectedly.\n", lineNum);
119          return -1;
120        }
121 +    
122 +      the_token = strtok( readLine, " ,;\t" );
123 +      if ( the_token != NULL)
124 +        if (!strcasecmp("begin", the_token)) {
125 +          the_token = strtok( NULL, " ,;\t" );
126 +          if ( the_token != NULL){
127 +            foundText = !strcasecmp( startText, the_token );
128 +          }
129 +        }
130 +    
131 +      if (!foundText) {
132 +        if (!theStream.eof()) {
133 +          theStream.getline(readLine, MAXLEN);
134 +          lineNum++;
135 +        } else {
136 +          printf( "Error fast forwarding stream at line %d: "
137 +                  "stream ended unexpectedly.\n", lineNum);
138 +          return -1;
139 +        }
140 +      }
141      }
142 +    return lineNum;
143    }
72 –  return lineNum;
73 – }
144  
145 < int countTokens(char *line, char *delimiters) {
146 <  /* PURPOSE: RETURN A COUNT OF THE NUMBER OF TOKENS ON THE LINE. */
145 >  int countTokens(char *line, char *delimiters) {
146 >    /* PURPOSE: RETURN A COUNT OF THE NUMBER OF TOKENS ON THE LINE. */
147    
148 <  char *working_line;   /* WORKING COPY OF LINE. */
149 <  int ntokens;          /* NUMBER OF TOKENS FOUND IN LINE. */
150 <  char *strtok_ptr;     /* POINTER FOR STRTOK. */
148 >    char *working_line;   /* WORKING COPY OF LINE. */
149 >    int ntokens;          /* NUMBER OF TOKENS FOUND IN LINE. */
150 >    char *strtok_ptr;     /* POINTER FOR STRTOK. */
151  
152 <  strtok_ptr= working_line= strdup(line);
152 >    strtok_ptr= working_line= strdup(line);
153  
154 <  ntokens=0;
155 <  while (strtok(strtok_ptr,delimiters)!=NULL)
156 <    {
157 <      ntokens++;
158 <      strtok_ptr=NULL;
159 <    }
154 >    ntokens=0;
155 >    while (strtok(strtok_ptr,delimiters)!=NULL)
156 >      {
157 >        ntokens++;
158 >        strtok_ptr=NULL;
159 >      }
160  
161 <  free(working_line);
162 <  return(ntokens);
163 < }
161 >    free(working_line);
162 >    return(ntokens);
163 >  }
164  
165 < char* TrimSpaces(char *str) {
166 <  size_t len;
167 <  char *right, *left;
165 >  int isEndLine(char *line) {
166 >    char *working_line;
167 >    char *foo;
168    
169 <  if (strlen(str) == 0) return(str);
169 >    working_line = strdup(line);
170    
171 <  /* Trim whitespace from left side */
172 <  for (left = str; isspace(*left); left++);
173 <  
174 <  /* Trim whitespace from right side */
175 <  if ((len = strlen(left)))
176 <    {
107 <      right = left + (len - 1);
108 <      
109 <      while (isspace(*right))
110 <        {
111 <          *right = '\0';
112 <          right--;
113 <        }
171 >    foo = strtok(working_line, " ,;\t");
172 >
173 >    if (foo != NULL) {
174 >
175 >      if (!strcasecmp(foo, "end")) return 1;
176 >
177      }
178 +
179 +    return 0;
180 +  }
181    
182 <  /* Only do the str copy if their was spaces to the left */
183 <  if (left != str)
184 <    strcpy(str, left);
185 <  
186 <  return (str);
182 >  std::string OOPSE_itoa(int value, unsigned int base) {    
183 >    const char digitMap[] = "0123456789abcdef";
184 >    std::string buf;
185 >
186 >    if (base == 0 || base > 16) {      
187 >      return buf;
188 >    }
189 >
190 >    if (value == 0) {
191 >      buf = "0";
192 >      return buf;
193 >    }
194 >    
195 >    // Take care negative int:
196 >        
197 >    std::string sign;    
198 >    int _value = value;
199 >    if (value < 0) {
200 >      _value = -value;
201 >      sign = "-";
202 >    }
203 >
204 >    // Translating number to string with base:
205 >    for (int i = 30; _value && i ; --i) {
206 >      buf = digitMap[ _value % base ] + buf;
207 >      _value /= base;
208 >    }
209 >    return sign.append(buf);
210 >  }
211 >
212 >
213 >  std::string getPrefix(const std::string& str) {
214 >    return str.substr(0, str.rfind('.'));
215 >  }
216 >
217 >  std::string getSuffix(const std::string& str) {
218 >    return str.substr(0, str.find('.'));
219 >  }
220 >
221 > bool isInteger(const std::string& str) {
222 >
223 >    bool result = false;
224 >
225 >    std::string::const_iterator i = str.begin();    
226 >    if (i != str.end() && (*i == '+' || *i == '-' || std::isdigit(*i) )) {
227 >        ++i;        
228 >        while (i != str.end() && std::isdigit(*i))
229 >            ++i;
230 >        if (i == str.end())
231 >            result = true;
232 >    }
233 >    
234 >    return result;
235   }
236  
237 < int isEndLine(char *line) {
238 <  char *working_line;
239 <  char *foo;
126 <  
127 <  working_line = strdup(line);
128 <  
129 <  foo = strtok(working_line, " ,;\t");
237 > bool CaseInsensitiveEquals(const char ch1, const char ch2) {
238 >  return std::toupper((unsigned char)ch1) == std::toupper((unsigned char)ch2);
239 > }
240  
241 < if (!strcasecmp(foo, "end")) return 1;
242 <
243 < return 0;
241 > size_t CaseInsensitiveFind(const std::string& str1, const std::string& str2) {
242 >  std::string::const_iterator pos = std::search(str1.begin(), str1.end(), str2.begin(), str2.end(), CaseInsensitiveEquals);
243 >  if (pos == str1.end())
244 >    return std::string::npos;
245 >  else
246 >    return pos - str1.begin();
247   }
248 +
249 + }

Diff Legend

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