StringTo.h

Go to the documentation of this file.

/* Copyright 2006-2009 Savarese Software Research Corporation
 *
 * 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
 *
 *     https://www.savarese.com/software/ApacheLicense-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.
 */

#ifndef __SSRC_WSPR_UTILITY_STRING_TO_H
#define __SSRC_WSPR_UTILITY_STRING_TO_H

#include <ssrc/wispers-packages.h>

#include <typeinfo>
#include <sstream>
#include <cstring>

__BEGIN_NS_SSRC_WSPR_UTILITY

using std::string;
using std::istringstream;

#if defined(__GNUC__) && (__GNUC__ >= 4)
#define __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#endif

class StringTo {
  istringstream _istream;

public:
  typedef istringstream::fmtflags fmtflags;
  typedef istringstream::iostate iostate;

  StringTo(const StringTo &) { }

  StringTo() { }

  template<typename T>  T cast(const string & str)
    SSRC_DECL_THROW(std::bad_cast)
  {
    T result;

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
    _istream.clear();
    _istream.rdbuf()->pubsetbuf(const_cast<char *>(str.c_str()), str.size());
    //    _istream.seekg(0);
#else
    _istream.str(str);
#endif

    if(!(_istream >> result))
      throw std::bad_cast();

    return result;
  }

  template<typename T>  T cast(const char *str)
    SSRC_DECL_THROW(std::bad_cast)
  {
    T result;

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
    _istream.clear();
    _istream.rdbuf()->pubsetbuf(const_cast<char *>(str), std::strlen(str));
    //    _istream.seekg(0);
#else
    _istream.str(str);
#endif

    if(!(_istream >> result))
      throw std::bad_cast();

    return result;
  }

  fmtflags flags() const {
    return _istream.flags();
  }

  fmtflags flags(const fmtflags flags) {
    return _istream.flags(flags);
  }

  fmtflags setf(const fmtflags flags) {
    return _istream.setf(flags);
  }

  fmtflags setf(const fmtflags flags,
                               const fmtflags mask)
  {
    return _istream.setf(flags, mask);
  }

  void unsetf(const fmtflags flags) {
    _istream.unsetf(flags);
  }

  iostate rdstate() const {
    return _istream.rdstate();
  }

  void clear(iostate state = istringstream::goodbit) {
    _istream.clear(state);
  }

  void setstate(iostate state) {
    _istream.setstate(state);
  }

};

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#undef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#endif

template<typename T>
inline T string_to(const string & str)
  SSRC_DECL_THROW(std::bad_cast)
{
  StringTo number_cast;
  return number_cast.cast<T>(str);
}

template<>
inline string string_to<string>(const string & str)
  SSRC_DECL_THROW(std::bad_cast)
{
  return str;
}

template<>
inline const char * string_to<const char *>(const string & str)
  SSRC_DECL_THROW(std::bad_cast)
{
  return str.c_str();
}

template<typename T>
inline T string_to(const char *str)
  SSRC_DECL_THROW(std::bad_cast)
{
  StringTo number_cast;
  return number_cast.cast<T>(str);
}

template<>
inline string string_to<string>(const char *str)
  SSRC_DECL_THROW(std::bad_cast)
{
  return string(str);
}

template<>
inline const char * string_to<const char *>(const char *str)
  SSRC_DECL_THROW(std::bad_cast)
{
  return str;
}

__END_NS_SSRC_WSPR_UTILITY

#endif