NICE_Core/core/basics/StringTools.h

/** 
 * @file StringTools.h
 * @brief some string handling routines
 * @author Erik Rodner
 * @date 19.09.2007

 */
#ifndef STRINGTOOLSINCLUDE
#define STRINGTOOLSINCLUDE

#include <vector>
#include <string>
#include <sstream>

#include <core/vector/VectorT.h>

namespace NICE
{

/** @brief some string handling routines */
class StringTools
{
public:
	/** normalize the std::string value, remove leading and
	 finishing whitespaces, tabulars, a finishing semicolon
	 @param s input std::string which will be modified
	 */
	static void normalize_string(std::string & s);

	/** split a std::string 
	 @param s input string
	 @param splitChar character which was used for seperation
	 @param list resulting list of sub strings
	 */
	static void split(const std::string & s, char splitChar, std::vector<
			std::string> & list);

	/** split a std::string and convert the strings to double values
	 @param input std::string value
	 @param splitChar character which was used as a seperation
	 @param x resulting std::vector of double values
	 */
	static void splitVector(const std::string & s, char splitChar,
			NICE::Vector & x);

	/** remove a leading and a finishing character
	 @param value input std::string value
	 @param trimChar e.g.
	 */
	static void trimbounds(std::string & value, char trimChar);

	/** chomp off the end-of-line characters 
	 @param s input and output string
	 */
	static std::string chomp(std::string s);

	/** whatever */
	static std::string trim(std::string s, const std::string& drop = " ");

	/** trims the filename to be without directories, similar to basename in linux
	 @param str input string
	 @param extension specifies if output is with extension or not
	 */
	static std::string baseName(const std::string& str, bool extension = true);

	/** perform regular expression matching and return true if the string \c s
	 *  matches the regular expression in \c regex (GNU regex style!). 
	 */
	static bool regexMatch(const std::string & s, const std::string & regex);

	/** perform regular expression matching and return true if the string \c s
	 *  matches the regular expression in \c regex (GNU regex style!), 
	 *  sub-pattern matches are stored in submatches and denoted with (...) in
	 *  the regular expression.
	 *  @note submatches[0] is the whole match and submatches[i] is the i'th sub-pattern match
	 */
	static bool regexMatch(const std::string & s, const std::string & regex,
			std::vector<std::string> & submatches);

	/** substitute a regular expression match with \c subst */
	static bool regexSubstitute(std::string & s, const std::string & regex,
			const std::string & subst);

	/** convert a string to another type using stringstream */
	template<class F>
	static F convert(const std::string & s);

	/** convert a string to another type using stringstream and returning true on success and
	 * false if there is a parsing error */
	template<class F>
	static bool convert(const std::string & s, F & i);

	/** convert another type to a string using stringstream */
	template<class F>
	static std::string convertToString(const F & s);

	/** convert another type to a string using stringstream */
	template<class F>
	static std::string convertToString(const F & s, uint precision);

};

// template implementations

template<class F>
F StringTools::convert(const std::string & s)
{
	std::istringstream is(s);
	F i;
	is >> i;
	return i;
}

template<class F>
bool StringTools::convert(const std::string & s, F & i)
{
	std::istringstream is(s);
	is >> i;
	return (!is.fail());
}

template<class F>
std::string StringTools::convertToString(const F & s)
{
	std::ostringstream os;
	os << s;
	return os.str();
}

template<class F>
std::string StringTools::convertToString(const F & s, uint precision)
{
	std::ostringstream os;
	os.precision(precision);
	os.setf(std::ios::fixed,std::ios::floatfield);
	os << s;
	return os.str();
}

} // namespace

#endif