Line data    Source code

       1             : #ifndef __casac_string_conversions__
       2             : #define __casac_string_conversions__
       3             : 
       4             : #include <cstdlib>
       5             : 
       6             : typedef unsigned int uInt;
       7             : 
       8           0 : bool stringtobool( const std::string &str ) {
       9           0 :     const char *data = str.data();
      10           0 :     while ( *data && isspace(*data) ) ++data;
      11           0 :     if (!strncasecmp(data,"true",4)) return true;
      12           0 :     if (!strncasecmp(data,"false",5)) return false;
      13           0 :     if (isdigit(*data) || *data == '+' || *data == '-') {
      14           0 :         const char *digit = data;
      15           0 :         while (*digit == '+' || *digit == '-') ++digit;
      16           0 :         if (isdigit(*digit)) {
      17           0 :             while (*digit && (isdigit(*digit))) ++digit;
      18           0 :             if (*digit == '.') return atof(data) != 0.0 ? true : false;
      19           0 :             else return atoi(data) != 0 ? true : false;
      20             :         } else {
      21           0 :             return false;
      22             :         }
      23             :     }
      24           0 :     return false;
      25             : }
      26             : 
      27           0 : inline int stringtoint( const std::string &str ) {
      28           0 :     const char *data = str.data();
      29           0 :     return atoi(data);
      30             : }
      31             : 
      32           0 : inline unsigned int stringtouInt( const std::string &str ) {
      33           0 :     const char *data = str.data();
      34           0 :     return strtoul(data, NULL, 10);
      35             : }
      36             : 
      37             : inline long long stringtolong( const std::string &str ) {
      38             :     const char *data = str.data();
      39             :     return (long long)atol(data);
      40             : }
      41             : 
      42             : 
      43           0 : inline double stringtodouble( const std::string &str ) {
      44           0 :     const char *data = str.data();
      45           0 :     return atof(data);
      46             : }
      47             : 
      48             : #define STRINGTOCOMPLEX_DEFINITION(TYPE,NAME)           \
      49             : inline TYPE NAME( const std::string &str ) {                \
      50             :     const char *data = str.data();                      \
      51             :     return TYPE(atof(data),0.0);                        \
      52             : }
      53             : 
      54           0 : STRINGTOCOMPLEX_DEFINITION(std::complex<double>,stringtocomplex)
      55             : 
      56             : #define TOSTRHELPERS(NAME,PTR,NEW)                                      \
      57             : inline std::string PTR bool ## NAME( bool b ) {                         \
      58             :     return b ? NEW std::string("true") : NEW std::string("false");  \
      59             : }                                                                       \
      60             : inline std::string PTR NAME( bool b ) {                                 \
      61             :     return b ? NEW std::string("true") : NEW std::string("false");  \
      62             : }                                                                       \
      63             : inline std::string PTR int ## NAME( long i ) {                  \
      64             :     char buff[256];                                                     \
      65             :     sprintf( buff, "%ld", i );                                                \
      66             :     return NEW std::string( (const char *) buff );                      \
      67             : }                                                                       \
      68             : inline std::string PTR NAME( long i ) {                                 \
      69             :     char buff[256];                                                     \
      70             :     sprintf( buff, "%ld", i );                                                \
      71             :     return NEW std::string( (const char *) buff );                      \
      72             : }                                                                       \
      73             : inline std::string PTR uInt ## NAME( unsigned long i ) {                        \
      74             :     char buff[256];                                                     \
      75             :     sprintf( buff, "%lu", i );                                                \
      76             :     return NEW std::string( (const char *) buff );                      \
      77             : }                                                                       \
      78             : inline std::string PTR NAME( unsigned long i ) {                                        \
      79             :     char buff[256];                                                     \
      80             :     sprintf( buff, "%lu", i );                                                \
      81             :     return NEW std::string( (const char *) buff );                      \
      82             : }                                                                       \
      83             : inline std::string PTR long ## NAME( long long  l ) {                                   \
      84             :     char buff[256];                                                     \
      85             :     sprintf( buff, "%lld", l );                                               \
      86             :     return NEW std::string( (const char *) buff );                      \
      87             : }                                                                       \
      88             : inline std::string PTR NAME( long long l ) {                                    \
      89             :     char buff[256];                                                     \
      90             :     sprintf( buff, "%lld", l );                                               \
      91             :     return NEW std::string( (const char *) buff );                      \
      92             : }                                                                       \
      93             : inline std::string PTR double ## NAME( double d ) {                     \
      94             :     char buff[256];                                                     \
      95             :     sprintf( buff, "%f", d );                                         \
      96             :     return NEW std::string( (const char *) buff );                      \
      97             : }                                                                       \
      98             : inline std::string PTR NAME( double d ) {                               \
      99             :     char buff[256];                                                     \
     100             :     sprintf( buff, "%f", d );                                         \
     101             :     return NEW std::string( (const char *) buff );                      \
     102             : }                                                                       \
     103             : inline std::string PTR complex ## NAME( const std::complex<double> &c ) {\
     104             :     char buff[512];                                                     \
     105             :     sprintf( buff, "(%f,%f)", c.real(), c.imag() );                   \
     106             :     return NEW std::string( (const char *) buff );                      \
     107             : }                                                                       \
     108             : inline std::string PTR NAME( const std::complex<double> &c ) {                \
     109             :     char buff[512];                                                     \
     110             :     sprintf( buff, "(%f,%f)", c.real(), c.imag() );                   \
     111             :     return NEW std::string( (const char *) buff );                      \
     112             : }
     113             : 
     114           0 : TOSTRHELPERS(tostring,,)
     115           0 : TOSTRHELPERS(tostringptr,*,new)
     116             : 
     117           0 : inline std::string std_stringtostring(std::string s) { return s; }
     118             : 
     119             : #endif