ToString.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_TO_STRING_H
#define __SSRC_WSPR_UTILITY_TO_STRING_H

#include <ssrc/wispers-packages.h>

// Pull in std::bad_cast.
#include <typeinfo>
#include <sstream>

// TODO: Determine if it's possible to use a static buffer in
// configure.ac based on diagnostic test programs instead of
// hardcoding a specific compiler and version check.
#if defined(__GNUC__) && (__GNUC__ >= 4)
#define __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#endif

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#include <type_traits>
#endif

__BEGIN_NS_SSRC_WSPR_UTILITY

using std::string;
using std::ostringstream;

class ToString {
  // This is big enough to hold the string representations of a
  // 128-bit integer.  If the representation is longer, the buffer
  // will not be overrun, but the output will be truncated.
#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
  char _buffer[64];
#endif
  string _str;
  ostringstream _ostream;

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
  void set_static_buffer() {
    _ostream.rdbuf()->pubsetbuf(_buffer, sizeof(_buffer));
  }

  template<typename T> const string & cast_to_string(const T & obj,
                                                     const std::true_type &)
    SSRC_DECL_THROW(std::bad_cast)
  {
    _ostream.seekp(0);

    if(!(_ostream << obj))
      throw std::bad_cast();

    _str.assign(_buffer,
                std::min(static_cast<std::streampos>(sizeof(_buffer)),
                         _ostream.tellp()));
    return _str;
  }

  template<typename T> const char * cast_to_c_str(const T & obj,
                                                  const std::true_type &)
    SSRC_DECL_THROW(std::bad_cast)
  {
    _ostream.seekp(0);

    if(!(_ostream << obj))
      throw std::bad_cast();

    _buffer[std::min(static_cast<std::streampos>(sizeof(_buffer) - 1),
                     _ostream.tellp())] = 0;
    return _buffer;
  }
#endif

  template<typename T> const string & cast_to_string(const T & obj
#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
                                                     , const std::false_type &
#endif
                                                     )
    SSRC_DECL_THROW(std::bad_cast)
  {
    _ostream.str("");

    if(!(_ostream << obj))
      throw std::bad_cast();

    _str.assign(_ostream.str());

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
    set_static_buffer();
#endif
    return _str;
  }

  template<typename T> const char * cast_to_c_str(const T & obj
#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
                                                  , const std::false_type &
#endif
                                                  )
    SSRC_DECL_THROW(std::bad_cast)
  {
    _ostream.str("");

    if(!(_ostream << obj))
      throw std::bad_cast();

    _str.assign(_ostream.str());

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
    set_static_buffer();
#endif
    return _str.c_str();
  }

public:
  typedef ostringstream::fmtflags fmtflags;
  typedef ostringstream::iostate iostate;

  ToString(const ToString &) {
#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
    set_static_buffer();
#endif
  }

  ToString() {
#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
    set_static_buffer();
#endif
  }

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
  template<typename T> const string & operator()(const T & obj)
    SSRC_DECL_THROW(std::bad_cast)
  {
    return cast_to_string(obj, std::is_fundamental<T>());
  }

  template<typename T> const char * c_str(const T & obj)
    SSRC_DECL_THROW(std::bad_cast)
  {
    return cast_to_c_str(obj, std::is_fundamental<T>());
  }
#else
  template<typename T> const string & operator()(const T & obj)
    SSRC_DECL_THROW(std::bad_cast)
  {
    return cast_to_string(obj);
  }

  template<typename T> const char * c_str(const T & obj)
    SSRC_DECL_THROW(std::bad_cast)
  {
    return cast_to_c_str(obj);
  }
#endif

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

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

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

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

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

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

  void clear(iostate state = ostringstream::goodbit) {
    _ostream.clear(state);
  }

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

};

#ifdef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#undef __WSPR_LEXICAL_CAST_USE_STATIC_BUFFER
#endif

// Only intended for primitive types, otherwise static buffer may
// be too small.  Should really specialize behavior based on
// primitive type.
template<typename T>
inline string to_string(const T & obj)
  SSRC_DECL_THROW(std::bad_cast)
{
  ToString string_cast;
  return string_cast(obj);
}

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

template<>
inline string to_string<char *>(char * const & obj)
  SSRC_DECL_THROW(std::bad_cast)
{
  return obj;
}

__END_NS_SSRC_WSPR_UTILITY

#endif