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

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

Diff Legend

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