String.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_STRING_H_
#define SimTK_SimTKCOMMON_STRING_H_
 
/* -------------------------------------------------------------------------- *
 *                       Simbody(tm): SimTKcommon                             *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2005-15 Stanford University and the Authors.        *
 * Authors: Michael Sherman                                                   *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */
 
#include "SimTKcommon/internal/common.h"
#include "SimTKcommon/internal/ExceptionMacros.h"
#include "SimTKcommon/Scalar.h"
 
#include <iomanip>
#include <cstdio>
#include <string>
#include <limits>
#include <complex>
#include <sstream>
 
// Keeps MS VC++ quiet about sprintf, strcpy, etc.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
 
namespace SimTK {
 
template <class N> class negator;
template <class R> class conjugate;
 
class String : public std::string {
public:
 
String() { }
 
// uses default copy constructor, copy assignment, and destructor
 
String(const char* s) : std::string(s) { }
 
explicit String(char c) {push_back(c);}
 
String(const std::string& s) : std::string(s) { }
 
String(const String& s, int start, int len) : std::string(s,start,len) { }
 
operator const char*() const { return c_str(); }
 
char& operator[](int i) {
    assert(i >= 0);
    return std::string::operator[]((std::string::size_type)i);
}
 
char operator[](int i) const {
    assert(i >= 0);
    return std::string::operator[]((std::string::size_type)i);
}
 
char& operator[](std::string::size_type i) {return std::string::operator[](i);}
char operator[](std::string::size_type i) const {return std::string::operator[](i);}
 
int size() const {return (int)std::string::size();}
 
int length() const {return (int)std::string::length();}
 
explicit String(int i, const char* fmt="%d")
{   const int n=32; char buf[n]; snprintf(buf,n,fmt,i); (*this)=buf; }
explicit String(long i, const char* fmt="%ld")
{   const int n=64; char buf[n]; snprintf(buf,n,fmt,i); (*this)=buf; }
explicit String(long long i, const char* fmt="%lld")
{   const int n=64; char buf[n]; snprintf(buf,n,fmt,i); (*this)=buf; }
explicit String(unsigned int s, const char* fmt="%u")
{   const int n=32; char buf[n]; snprintf(buf,n,fmt,s); (*this)=buf; }
explicit String(unsigned long s, const char* fmt="%lu")
{   const int n=64; char buf[n]; snprintf(buf,n,fmt,s); (*this)=buf; }
explicit String(unsigned long long s, const char* fmt="%llu")
{   const int n=64; char buf[n]; snprintf(buf,n,fmt,s); (*this)=buf; }
 
SimTK_SimTKCOMMON_EXPORT explicit String(float r, const char* fmt="%.9g");
 
SimTK_SimTKCOMMON_EXPORT explicit String(double r, const char* fmt="%.17g");
 
explicit String(std::complex<float> r, const char* fmt="%.9g")
{   (*this)="(" + String(r.real(),fmt) + "," + String(r.imag(),fmt) + ")"; }
explicit String(std::complex<double> r, const char* fmt="%.17g")
{   (*this)="(" + String(r.real(),fmt) + "," + String(r.imag(),fmt) + ")"; }
 
explicit String(bool b) : std::string(b?"true":"false") { }
 
template <class T> inline explicit
String(const T& t);
 
template <class T> inline explicit
String(const T& t, int precision);
 
template <class T> explicit
String(const negator<T>& nt) {
    new (this) String(T(nt));
}
template <class T>
String(const negator<T>& nt, const char* fmt) {
    new (this) String(T(nt), fmt);
}
 
template <class T> explicit
String(const conjugate<T>& ct) {
    new (this) String(std::complex<T>(ct));
}
template <class T>
String(const conjugate<T>& ct, const char* fmt) {
    new (this) String(std::complex<T>(ct), fmt);
}
 
 
template <class T> inline bool tryConvertTo(T& out) const; // see below
 
template <class T> inline void convertTo(T& out) const; // see below
 
template <class T> T convertTo() const
{   T temp; convertTo<T>(temp); return temp; }
 
SimTK_SimTKCOMMON_EXPORT bool tryConvertToBool(bool& out) const;
 
SimTK_SimTKCOMMON_EXPORT bool tryConvertToFloat(float& out) const;
 
SimTK_SimTKCOMMON_EXPORT bool tryConvertToDouble(double& out) const;
SimTK_SimTKCOMMON_EXPORT String& toUpper();
SimTK_SimTKCOMMON_EXPORT String& toLower();
SimTK_SimTKCOMMON_EXPORT String& trimWhiteSpace();
SimTK_SimTKCOMMON_EXPORT String& replaceAllChar(char oldChar, char newChar);
static String toUpper(const std::string& in)
{   return String(in).toUpper(); }
static String toLower(const std::string& in)
{   return String(in).toLower(); }
static SimTK_SimTKCOMMON_EXPORT String trimWhiteSpace(const std::string& in);
String& replaceAllChar(const std::string& in, char oldChar, char newChar)
{   return String(in).replaceAllChar(oldChar, newChar); }
};
 
// All std::stream activity should be dealt with inline so that we don't have
// to worry about binary compatibility issues that can arise when passing
// streams through the API.
 
template <class T> inline
auto stringStreamInsertHelper(std::ostringstream& os, const T& t, bool)
    -> decltype(static_cast<std::ostringstream&>(os << t)) {
    os << t;
    return os;
}
 
 
template <class T> inline
auto stringStreamInsertHelper(std::ostringstream& os, const T& t, int)
                                                    -> std::ostringstream& {
    SimTK_ERRCHK1_ALWAYS(!"no stream insertion operator", "String::String(T)",
        "Type T=%s has no stream insertion operator<<(T) and there "
        "is no specialized String(T) constructor.",
        NiceTypeName<T>::namestr().c_str());
    return os;
}
 
template <class T> inline
auto stringStreamExtractHelper(std::istringstream& is, T& t, bool)
    -> decltype(static_cast<std::istringstream&>(is >> t)) {
    is >> t;
    return is;
}
 
template <class T> inline
auto stringStreamExtractHelper(std::istringstream& is, T& t, int)
                                                    -> std::istringstream& {
    SimTK_ERRCHK1_ALWAYS(!"no stream extraction operator",
        "String::tryConvertTo<T>()",
        "Type T=%s has no stream extraction operator>>(T) and there "
        "is no specialized tryConvertTo<T>() constructor.",
        NiceTypeName<T>::namestr().c_str());
    return is;
}
 
// Implementation of the generic templatized String constructor.
template <class T> inline
String::String(const T& t) {
    std::ostringstream os;
    *this = stringStreamInsertHelper(os, t, true).str();
}
 
// Implementation of the generic templatized String constructor
// with precision.
// To ensure consistent behavior of ostream::setprecision() across operating
// systems and whether a build is debug or release, precision is bounded:
// 1 <= precision <= SimTK::LosslessNumDigitsReal
template <class T> inline
String::String(const T& t, int precision) {
    std::ostringstream os;
    if(precision < 1)
        precision = 1;
    else if(precision > SimTK::LosslessNumDigitsReal)
        precision = SimTK::LosslessNumDigitsReal;
    os << std::setprecision(precision);
    *this = stringStreamInsertHelper(os, t, true).str();
}
 
 
// This namespace-level static method should not be necessary but gcc 4.1
// still has trouble with template specialization for template member
// functions. So rather than specializing the tryConvertTo() member, I'm
// specializing this helper function instead.
template <class T> inline static
bool tryConvertStringTo(const String& value, T& out) {
    std::istringstream sstream(value);
    stringStreamExtractHelper(sstream, out, true);
    if (sstream.fail()) return false;
    if (sstream.eof()) return true;
    // Successful conversion but didn't use all the characters. Maybe the
    // rest is just whitespace?
    std::ws(sstream);       // Skip trailing whitespace if any.
    return sstream.eof();   // We must have used up the whole string now.
}
 
// This specialization ensures that "true" and "false" are recognized as
// values for bools (with any case).
template <> inline
bool tryConvertStringTo(const String& value, bool& out)
{   return value.tryConvertToBool(out); }
 
// Specialization to ensure recognition of non-finite values NaN, Inf, etc.
template <> inline
bool tryConvertStringTo(const String& value, float& out)
{   return value.tryConvertToFloat(out); }
 
// Specialization to ensure recognition of non-finite values NaN, Inf, etc.
template <> inline
bool tryConvertStringTo(const String& value, double& out)
{   return value.tryConvertToDouble(out); }
 
// This specialization ensures that we get the whole String including
// leading and trailing white space. Of course this is not useful for
// anything but may occur as a result of some higher-level templatized
// method that doesn't know what type it is converting here.
template<> inline
bool tryConvertStringTo(const String& value, String& out)
{   out = value; return true; }
 
// Same as above but for std::string output rather than String.
template<> inline
bool tryConvertStringTo(const String& value, std::string& out)
{   out = value; return true; }
 
template <class T> inline
bool tryConvertStringTo(const String& value, negator<T>& out) {
    T nonnegated;
    if (!tryConvertStringTo(value, nonnegated)) return false;
    out = nonnegated;
    return true;
}
 
template <class T> inline
bool tryConvertStringTo(const String& value, conjugate<T>& out) {
    std::complex<T> cmplx;
    if (!tryConvertStringTo(value, cmplx)) return false;
    out = cmplx;
    return true;
}
 
 
// This partial specialization ensures that you can't interpret
// a String as a pointer.
template<class T> inline static
bool tryConvertStringTo(const String& value, T*& out) {
    SimTK_ERRCHK1_ALWAYS(false, "SimTK::convertStringTo(value,T*)",
        "Can't interpret a string as a pointer (%s*).",
        NiceTypeName<T>::namestr().c_str());
    return false;
}
 
template <class T> inline bool
String::tryConvertTo(T& out) const
{   return tryConvertStringTo(*this, out); }
 
template <class T> inline void
String::convertTo(T& out) const {
    const int MaxStr = 50;
    const bool convertOK = tryConvertTo<T>(out);
    if (convertOK) return;
 
    // Make sure we don't try to output more than MaxStr characters of
    // the bad string in the error message.
    String shorter = this->substr(0, MaxStr);
    if (shorter.size() < this->size()) shorter += " ...";
    SimTK_ERRCHK2_ALWAYS(convertOK, "String::convertTo()",
        "Couldn't interpret string '%s' as type T=%s.",
        shorter.c_str(), NiceTypeName<T>::namestr().c_str());
}
 
template <class T> inline static
void convertStringTo(const String& in, T& out)
{   in.convertTo<T>(out); }
 
template <class T> inline static
T convertStringTo(const String& in)
{   return in.convertTo<T>(); }
 
} // namespace SimTK
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif // SimTK_SimTKCOMMON_STRING_H_