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 <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") 
{   char buf[32]; sprintf(buf,fmt,i); (*this)=buf; }
explicit String(long i, const char* fmt="%ld") 
{   char buf[64]; sprintf(buf,fmt,i); (*this)=buf; }
explicit String(long long i, const char* fmt="%lld") 
{   char buf[64]; sprintf(buf,fmt,i); (*this)=buf; }
explicit String(unsigned int s, const char* fmt="%u")  
{   char buf[32]; sprintf(buf,fmt,s); (*this)=buf; }
explicit String(unsigned long s, const char* fmt="%lu") 
{   char buf[64]; sprintf(buf,fmt,s); (*this)=buf; }
explicit String(unsigned long long s, const char* fmt="%llu") 
{   char buf[64]; sprintf(buf,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");

SimTK_SimTKCOMMON_EXPORT explicit String(long double r, 
                                         const char* fmt="%.21Lg");

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(std::complex<long double> r, const char* fmt="%.21Lg")    
{   (*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); // see below

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 bool tryConvertToLongDouble(long 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.
 // Hide from Doxygen
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;
}

template <class T> inline
String::String(const T& t) {
    std::ostringstream os;
    *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); }

// Specialization to ensure recognition of non-finite values NaN, Inf, etc.
template <> inline 
bool tryConvertStringTo(const String& value, long double& out)
{   return value.tryConvertToLongDouble(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_