src/utils/StringUtils.cpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
 * [4]  Vardeman & Gezelter, in progress (2009).                        
 */

#include <algorithm>
#include "utils/StringUtils.hpp"

namespace OpenMD {
  std::string UpperCase(const std::string& S) {
    std::string uc = S;
    unsigned int n = uc.size();
    for (unsigned int j = 0; j < n; j++) {   
      char sj = uc[j];
      if (sj >= 'a' && sj <= 'z') uc[j] = (char)(sj - ('a' - 'A'));
    }
    return uc;
  }

  std::string LowerCase(const std::string& S) {
    std::string lc = S;
    unsigned int n = lc.size();
    for (unsigned int j = 0; j < n; j++) {
      char sj = lc[j];
      if (sj >= 'A' && sj <= 'Z') lc[j] = (char)(sj + ('a' - 'A'));
    }
    return lc;
  }

  char* trimSpaces(char *str) {
    size_t len;
    char *right, *left;

    if (strlen(str) == 0) return(str);
  
    /* Trim whitespace from left side */
    for (left = str; isspace(*left); left++);

    /* Trim whitespace from right side */
    if ((len = strlen(left)))
      {
        right = left + (len - 1);
      
        while (isspace(*right))
          {
            *right = '\0';
            right--;
          }
      }

    /* Only do the str copy if there were spaces to the left */
    if (left != str)
      strcpy(str, left);
  
    return (str);
  }

  int findBegin(std::istream &theStream, const char* startText ){
    const int MAXLEN = 1024;
    char readLine[MAXLEN];   
    int foundText = 0;
    int lineNum;
    char* the_token;
    char* eof_test;

    // rewind the stream
    theStream.seekg (0, std::ios::beg);
    lineNum = 0;
  
    if (!theStream.eof()) {
      theStream.getline(readLine, MAXLEN);
      lineNum++;
    } else {
      printf( "Error fast forwarding stream: stream is empty.\n");
      return -1;
    }
  
    while ( !foundText ) {
    
      if (theStream.eof()) {
        printf("Error fast forwarding stream at line %d: "
               "stream ended unexpectedly.\n", lineNum);
        return -1;
      }
    
      the_token = strtok( readLine, " ,;\t" );
      if ( the_token != NULL)
        if (!strcasecmp("begin", the_token)) {
          the_token = strtok( NULL, " ,;\t" );
          if ( the_token != NULL){
            foundText = !strcasecmp( startText, the_token );
          }
        }
    
      if (!foundText) {
        if (!theStream.eof()) {
          theStream.getline(readLine, MAXLEN);
          lineNum++;
        } else {
          printf( "Error fast forwarding stream at line %d: "
                  "stream ended unexpectedly.\n", lineNum);
          return -1;
        }
      }
    }
    return lineNum;
  }

  int countTokens(char *line, char *delimiters) {
    /* PURPOSE: RETURN A COUNT OF THE NUMBER OF TOKENS ON THE LINE. */
  
    char *working_line;   /* WORKING COPY OF LINE. */
    int ntokens;          /* NUMBER OF TOKENS FOUND IN LINE. */
    char *strtok_ptr;     /* POINTER FOR STRTOK. */

    strtok_ptr= working_line= strdup(line);

    ntokens=0;
    while (strtok(strtok_ptr,delimiters)!=NULL)
      {
        ntokens++;
        strtok_ptr=NULL;
      }

    free(working_line);
    return(ntokens);
  }

  int isEndLine(char *line) {
    char *working_line;
    char *foo;
  
    working_line = strdup(line);
  
    foo = strtok(working_line, " ,;\t");

    if (foo != NULL) {

      if (!strcasecmp(foo, "end")) return 1;

    }
 
    return 0;
  }
  
  std::string OpenMD_itoa(int value, unsigned int base) {    
    const char digitMap[] = "0123456789abcdef"; 
    std::string buf;

    if (base == 0 || base > 16) {      
      return buf;
    }

    if (value == 0) {
      buf = "0";
      return buf;
    }
    
    // Take care negative int:
        
    std::string sign;    
    int _value = value; 
    if (value < 0) {
      _value = -value;
      sign = "-";
    }

    // Translating number to string with base:
    for (int i = 30; _value && i ; --i) {
      buf = digitMap[ _value % base ] + buf;
      _value /= base;
    }
    return sign.append(buf);
  }


  std::string getPrefix(const std::string& str) {
    return str.substr(0, str.rfind('.'));
  }

  std::string getSuffix(const std::string& str) {
    return str.substr(0, str.find('.'));
  }

  bool isInteger(const std::string& str) {
    
    bool result = false;
    
    std::string::const_iterator i = str.begin();    
    if (i != str.end() && (*i == '+' || *i == '-' || std::isdigit(*i) )) {
      ++i;        
      while (i != str.end() && std::isdigit(*i))
        ++i;
      if (i == str.end())
        result = true;
    }
    
    return result;
  }
  
bool CaseInsensitiveEquals(const char ch1, const char ch2) {
  return std::toupper((unsigned char)ch1) == std::toupper((unsigned char)ch2);
}

size_t CaseInsensitiveFind(const std::string& str1, const std::string& str2) {
  std::string::const_iterator pos = std::search(str1.begin(), str1.end(), str2.begin(), str2.end(), CaseInsensitiveEquals);
  if (pos == str1.end())
    return std::string::npos;
  else
    return pos - str1.begin();
}

  /**
   *    memparse - parse a string with mem suffixes into a number
   *    @ptr: Where parse begins
   *    @retptr: (output) Pointer to next char after parse completes
   *
   *    Parses a string into a number.  The number stored at @ptr is
   *    potentially suffixed with %K (for kilobytes, or 1024 bytes),
   *    %M (for megabytes, or 1048576 bytes), or %G (for gigabytes, or
   *    1073741824).  If the number is suffixed with K, M, or G, then
   *    the return value is the number multiplied by one kilobyte, one
   *    megabyte, or one gigabyte, respectively.
   */  
  unsigned long long memparse (char *ptr,  char **retptr) {
    unsigned long long ret = strtoull (ptr, retptr, 0);
    
    switch (**retptr) {
    case 'G':
    case 'g':
      ret <<= 10;
    case 'M':
    case 'm':
      ret <<= 10;
    case 'K':
    case 'k':
      ret <<= 10;
      (*retptr)++;
    default:
      break;
    }
    return ret;
  }

}
Revision:	1596
Committed:	Mon Jul 25 17:30:53 2011 UTC (13 years, 9 months ago) by gezelter
File size:	7919 byte(s)
Log Message:	Updated the BlockSnapshotManager to use a specified memory footprint in constructor and not to rely on physmem and residentMem to figure out free memory. DynamicProps is the only program that uses the BlockSnapshotManager, so substantial changes were needed there as well.
#	User	Rev	Content
1	gezelter	406	/*
2	gezelter	246	* 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	gezelter	1390	* 1. Redistributions of source code must retain the above copyright
10	gezelter	246	* notice, this list of conditions and the following disclaimer.
11			*
12	gezelter	1390	* 2. Redistributions in binary form must reproduce the above copyright
13	gezelter	246	* 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	gezelter	1390	*
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 & Gezelter, in progress (2009).
40	gezelter	246	*/
41	tim	1024
42	gezelter	1558	#include <algorithm>
43	tim	3	#include "utils/StringUtils.hpp"
44	gezelter	2
45	gezelter	1390	namespace OpenMD {
46	gezelter	406	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	gezelter	2	}
55
56	gezelter	406	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	gezelter	2	}
65	gezelter	97
66	gezelter	406	char* trimSpaces(char *str) {
67			size_t len;
68			char right, left;
69	chrisfen	105
70	gezelter	406	if (strlen(str) == 0) return(str);
71	chrisfen	105
72	gezelter	406	/* Trim whitespace from left side */
73			for (left = str; isspace(*left); left++);
74	chrisfen	105
75	gezelter	406	/* Trim whitespace from right side */
76			if ((len = strlen(left)))
77			{
78			right = left + (len - 1);
79	chrisfen	105
80	gezelter	406	while (isspace(*right))
81			{
82			*right = '\0';
83			right--;
84			}
85			}
86	chrisfen	105
87	gezelter	406	/* Only do the str copy if there were spaces to the left */
88			if (left != str)
89			strcpy(str, left);
90	chrisfen	105
91	gezelter	406	return (str);
92			}
93	chrisfen	105
94	skuang	1305	int findBegin(std::istream &theStream, const char* startText ){
95	gezelter	406	const int MAXLEN = 1024;
96			char readLine[MAXLEN];
97			int foundText = 0;
98			int lineNum;
99			char* the_token;
100			char* eof_test;
101	gezelter	97
102	gezelter	406	// rewind the stream
103			theStream.seekg (0, std::ios::beg);
104			lineNum = 0;
105	gezelter	97
106	gezelter	406	if (!theStream.eof()) {
107			theStream.getline(readLine, MAXLEN);
108			lineNum++;
109			} else {
110			printf( "Error fast forwarding stream: stream is empty.\n");
111	gezelter	97	return -1;
112			}
113	gezelter	406
114			while ( !foundText ) {
115	chrisfen	105
116	gezelter	406	if (theStream.eof()) {
117			printf("Error fast forwarding stream at line %d: "
118			"stream ended unexpectedly.\n", lineNum);
119			return -1;
120	chrisfen	105	}
121
122	gezelter	406	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	gezelter	97	}
141			}
142	gezelter	406	return lineNum;
143	gezelter	97	}
144
145	gezelter	406	int countTokens(char line, char delimiters) {
146			/* PURPOSE: RETURN A COUNT OF THE NUMBER OF TOKENS ON THE LINE. */
147	gezelter	97
148	gezelter	406	char working_line; / WORKING COPY OF LINE. */
149			int ntokens; /* NUMBER OF TOKENS FOUND IN LINE. */
150			char strtok_ptr; / POINTER FOR STRTOK. */
151	gezelter	97
152	gezelter	406	strtok_ptr= working_line= strdup(line);
153	gezelter	97
154	gezelter	406	ntokens=0;
155			while (strtok(strtok_ptr,delimiters)!=NULL)
156			{
157			ntokens++;
158			strtok_ptr=NULL;
159			}
160	gezelter	97
161	gezelter	406	free(working_line);
162			return(ntokens);
163			}
164	gezelter	97
165	gezelter	406	int isEndLine(char *line) {
166			char *working_line;
167			char *foo;
168	gezelter	97
169	gezelter	406	working_line = strdup(line);
170	gezelter	97
171	gezelter	406	foo = strtok(working_line, " ,;\t");
172	gezelter	97
173	gezelter	406	if (foo != NULL) {
174	gezelter	107
175	gezelter	406	if (!strcasecmp(foo, "end")) return 1;
176	gezelter	107
177	gezelter	406	}
178
179			return 0;
180	gezelter	107	}
181	gezelter	406
182	gezelter	1390	std::string OpenMD_itoa(int value, unsigned int base) {
183	gezelter	406	const char digitMap[] = "0123456789abcdef";
184			std::string buf;
185	gezelter	246
186	gezelter	406	if (base == 0 \|\| base > 16) {
187			return buf;
188			}
189	gezelter	246
190	gezelter	406	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	gezelter	246
204	gezelter	406	// 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	gezelter	246	return str.substr(0, str.find('.'));
219	gezelter	406	}
220	gezelter	246
221	gezelter	1558	bool isInteger(const std::string& str) {
222
223	tim	838	bool result = false;
224	gezelter	1558
225	tim	838	std::string::const_iterator i = str.begin();
226			if (i != str.end() && (i == '+' \|\| i == '-' \|\| std::isdigit(*i) )) {
227	gezelter	1558	++i;
228			while (i != str.end() && std::isdigit(*i))
229			++i;
230			if (i == str.end())
231			result = true;
232	tim	838	}
233
234			return result;
235	gezelter	1558	}
236
237	tim	1024	bool CaseInsensitiveEquals(const char ch1, const char ch2) {
238			return std::toupper((unsigned char)ch1) == std::toupper((unsigned char)ch2);
239	tim	838	}
240	tim	1024
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	gezelter	1596	/**
250			* memparse - parse a string with mem suffixes into a number
251			* @ptr: Where parse begins
252			* @retptr: (output) Pointer to next char after parse completes
253			*
254			* Parses a string into a number. The number stored at @ptr is
255			* potentially suffixed with %K (for kilobytes, or 1024 bytes),
256			* %M (for megabytes, or 1048576 bytes), or %G (for gigabytes, or
257			* 1073741824). If the number is suffixed with K, M, or G, then
258			* the return value is the number multiplied by one kilobyte, one
259			* megabyte, or one gigabyte, respectively.
260			*/
261			unsigned long long memparse (char ptr, char *retptr) {
262			unsigned long long ret = strtoull (ptr, retptr, 0);
263
264			switch (**retptr) {
265			case 'G':
266			case 'g':
267			ret <<= 10;
268			case 'M':
269			case 'm':
270			ret <<= 10;
271			case 'K':
272			case 'k':
273			ret <<= 10;
274			(*retptr)++;
275			default:
276			break;
277			}
278			return ret;
279			}
280
281	tim	1024	}