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 (13 years, 9 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.
#	User	Rev	Content
1	gezelter	507	/*
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
42	gezelter	97	/**
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	gezelter	2	#include <string>
52	gezelter	1282	#include <string.h>
53	gezelter	97	#include <iostream>
54			#include <fstream>
55	gezelter	246	#include <sstream>
56	gezelter	2
57	gezelter	1390	namespace OpenMD {
58	gezelter	97
59			/**
60			* Converts a string to UPPER CASE
61			* @param S
62			*/
63	gezelter	246	std::string UpperCase(const std::string& S);
64	gezelter	97
65			/**
66			* Converts a string to lower case
67			* @param S
68			*/
69	gezelter	246	std::string LowerCase(const std::string& S);
70	gezelter	97
71			/**
72	chrisfen	105	* 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	gezelter	97	* 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	skuang	1305	int findBegin(std::istream &theStream, const char* startText );
88	gezelter	97
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	gezelter	246
106	tim	1024	bool CaseInsensitiveEquals(char ch1, char ch2);
107	gezelter	246
108	tim	1024	size_t CaseInsensitiveFind(const std::string& str1, const std::string& str2);
109
110
111	gezelter	246	/**
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	gezelter	406	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	gezelter	246	}
123	gezelter	406	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	tim	278	}
133	gezelter	406	return result;
134			}
135	tim	749
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	tim	838
148			bool isInteger(const std::string& str);
149	gezelter	406
150	gezelter	1390	std::string OpenMD_itoa(int value, unsigned int base = 10);
151	gezelter	406
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	tim	278
159	tim	845	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	gezelter	406
176	gezelter	1596	unsigned long long memparse (char ptr, char *retptr);
177	gezelter	406	}
178	gezelter	2	#endif