src/utils/StringUtils.hpp

/*
 * 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).                        
 */
 
/**
 * @file StringUtils.hpp
 * @author Dan Gezelter
 * @date 10/18/2004
 * @version 1.0
 */

#ifndef UTILS_STRINGUTILS_HPP
#define UTILS_STRINGUTILS_HPP
#include <string>
#include <string.h>
#include <iostream>
#include <fstream>
#include <sstream>

namespace OpenMD {
 
  /**
   * Converts a string to UPPER CASE
   * @param S
   */
  std::string UpperCase(const std::string& S);

  /**
   * Converts a string to lower case
   * @param S
   */
  std::string LowerCase(const std::string& S);

  /**
   * Removes left and right spaces from a string
   *
   * @param str  String to trim
   *
   * @return  char* to the trimed string
   */
  char* trimSpaces(char *str);

  /**
   * Finds the location of the string "begin <startText>" in an input stream.
   * @param theStream
   * @param startText
   *
   * @return the line number of the block within the theStream
   */
  int findBegin(std::istream &theStream, const char* startText );

  /**
   * Counts the number of tokens on line which are delimited by the characters 
   * listed in delimiters
   * @param line
   * @param delimiters
   */
  int countTokens(char *line, char *delimiters);

  /**
   * discovers whether or not the line contains the "end" token
   *
   * @param line  The line to test
   * 
   * @return int  (==1 if the line has "end", ==0 if not).
   */
  int isEndLine(char *line);

  bool CaseInsensitiveEquals(char ch1, char ch2);

  size_t CaseInsensitiveFind(const std::string& str1, const std::string& str2);


  /**
   * Convert a variable to a string
   * @param T data type
   * @param v data to be converted
   * @return a string
   */
  template<typename T>
  std::string toString(const T& v) {
    std::ostringstream oss;        
    if (!oss << v) {
      std::cerr << "toString Error" << std::endl;
    }
    return oss.str();
  }
  
  template<typename T>
  T lexi_cast(const std::string& str) {
    T result;
    std::istringstream iss(str);        
    if (!(iss >> result)) {
      std::cerr << "lexi_cast Error" << std::endl;
    }
    return result;
  }


  template<typename T>
  bool isType(const std::string& str) {
    T result;
    std::istringstream iss(str);        
    bool ret = true;
    if (!(iss >> result)) {
        ret = false;
    }
    return ret;
  }

  bool isInteger(const std::string& str);
  
  std::string OpenMD_itoa(int value, unsigned int base = 10);
  
  /**@todo need implementation */
  std::string getPrefix(const std::string& str);
  
  /**@todo need implementation */
  std::string getSuffix(const std::string& str);
  

template<class ContainerType>
std::string containerToString(const ContainerType& cont) {
    std::ostringstream oss;
    oss << "(";
    typename ContainerType::const_iterator i = cont.begin();
    if (i != cont.end()) {
        oss << *i;
        ++i;
    }
    for (; i != cont.end();++i) {
        oss << ", ";
        oss << *i;
    }
    oss << ")";
    return oss.str();
}  
  
  unsigned long long memparse (char *ptr,  char **retptr);
}  
#endif
Revision:	1596
Committed:	Mon Jul 25 17:30:53 2011 UTC (14 years, 3 months ago) by gezelter
File size:	5119 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.
#	Content
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. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above copyright
13	* 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	*
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	*/
41
42	/**
43	* @file StringUtils.hpp
44	* @author Dan Gezelter
45	* @date 10/18/2004
46	* @version 1.0
47	*/
48
49	#ifndef UTILS_STRINGUTILS_HPP
50	#define UTILS_STRINGUTILS_HPP
51	#include <string>
52	#include <string.h>
53	#include <iostream>
54	#include <fstream>
55	#include <sstream>
56
57	namespace OpenMD {
58
59	/**
60	* Converts a string to UPPER CASE
61	* @param S
62	*/
63	std::string UpperCase(const std::string& S);
64
65	/**
66	* Converts a string to lower case
67	* @param S
68	*/
69	std::string LowerCase(const std::string& S);
70
71	/**
72	* Removes left and right spaces from a string
73	*
74	* @param str String to trim
75	*
76	* @return char* to the trimed string
77	*/
78	char* trimSpaces(char *str);
79
80	/**
81	* Finds the location of the string "begin <startText>" in an input stream.
82	* @param theStream
83	* @param startText
84	*
85	* @return the line number of the block within the theStream
86	*/
87	int findBegin(std::istream &theStream, const char* startText );
88
89	/**
90	* Counts the number of tokens on line which are delimited by the characters
91	* listed in delimiters
92	* @param line
93	* @param delimiters
94	*/
95	int countTokens(char line, char delimiters);
96
97	/**
98	* discovers whether or not the line contains the "end" token
99	*
100	* @param line The line to test
101	*
102	* @return int (==1 if the line has "end", ==0 if not).
103	*/
104	int isEndLine(char *line);
105
106	bool CaseInsensitiveEquals(char ch1, char ch2);
107
108	size_t CaseInsensitiveFind(const std::string& str1, const std::string& str2);
109
110
111	/**
112	* Convert a variable to a string
113	* @param T data type
114	* @param v data to be converted
115	* @return a string
116	*/
117	template<typename T>
118	std::string toString(const T& v) {
119	std::ostringstream oss;
120	if (!oss << v) {
121	std::cerr << "toString Error" << std::endl;
122	}
123	return oss.str();
124	}
125
126	template<typename T>
127	T lexi_cast(const std::string& str) {
128	T result;
129	std::istringstream iss(str);
130	if (!(iss >> result)) {
131	std::cerr << "lexi_cast Error" << std::endl;
132	}
133	return result;
134	}
135
136
137	template<typename T>
138	bool isType(const std::string& str) {
139	T result;
140	std::istringstream iss(str);
141	bool ret = true;
142	if (!(iss >> result)) {
143	ret = false;
144	}
145	return ret;
146	}
147
148	bool isInteger(const std::string& str);
149
150	std::string OpenMD_itoa(int value, unsigned int base = 10);
151
152	/*@todo need implementation /
153	std::string getPrefix(const std::string& str);
154
155	/*@todo need implementation /
156	std::string getSuffix(const std::string& str);
157
158
159	template<class ContainerType>
160	std::string containerToString(const ContainerType& cont) {
161	std::ostringstream oss;
162	oss << "(";
163	typename ContainerType::const_iterator i = cont.begin();
164	if (i != cont.end()) {
165	oss << *i;
166	++i;
167	}
168	for (; i != cont.end();++i) {
169	oss << ", ";
170	oss << *i;
171	}
172	oss << ")";
173	return oss.str();
174	}
175
176	unsigned long long memparse (char ptr, char *retptr);
177	}
178	#endif