FrobbyStringStream.cpp

Go to the documentation of this file.

/* Frobby: Software for monomial ideal computations.
   Copyright (C) 2007 Bjarke Hammersholt Roune (www.broune.com)
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see http://www.gnu.org/licenses/.
*/
#include "stdinc.h"
#include "FrobbyStringStream.h"
 
#include <algorithm>
#include <exception>
 
// This is a replacement for stringstream, which may seem weird since
// stringstream should work perfectly fine for any purpose where
// FrobbyStringStream could be used. Unfortunately this is not the
// case.
//
// The sad truth is that stringstream is unusable due to its behavior
// when running out of memory - it just stops what it is doing and
// then returns without propagating the bad_alloc exception. Setting
// exception flags with the exception() method does not change this
// behavior. This is for GCC v. 3.4.4 and on GCC 4.1.2 I have tested
// that at least without setting exception() it fails silently, though
// not whether that can be changed by using exception().
//
// The advantage of FrobbyStringStream is that it does not try to be
// clever in any way, and so it avoids these issues.
 
FrobbyStringStream& FrobbyStringStream::operator<<(char character) {
  _str += character;
  return *this;
}
 
FrobbyStringStream& FrobbyStringStream::operator<<(unsigned long long integer) {
  appendIntegerToString(_str, integer);
  return *this;
}
 
FrobbyStringStream& FrobbyStringStream::operator<<(unsigned long integer) {
  appendIntegerToString(_str, integer);
  return *this;
}
 
FrobbyStringStream& FrobbyStringStream::operator<<(unsigned int integer) {
  appendIntegerToString(_str, integer);
  return *this;
}
 
FrobbyStringStream& FrobbyStringStream::operator<<(const mpz_class& integer) {
  appendIntegerToString(_str, integer);
  return *this;
}
 
FrobbyStringStream& FrobbyStringStream::operator<<(const string& text) {
  _str += text;
  return *this;
}
 
FrobbyStringStream& FrobbyStringStream::operator<<(const char* text) {
  _str += text;
  return *this;
}
 
string& FrobbyStringStream::str() {
  return _str;
}
 
const string& FrobbyStringStream::str() const {
  return _str;
}
 
FrobbyStringStream::operator const string&() const {
  return _str;
}
 
void FrobbyStringStream::appendIntegerToString(string& str,
                                               unsigned long integer) {
  unsigned long initialLength = str.size();
 
  // Append string representation of integer with digits in reverse
  // order.
  do {
    unsigned long quotient = integer / 10;
    unsigned long remainder = integer - quotient * 10; // faster than %
 
    char digit = static_cast<char>(remainder + '0');
    str += digit;
 
    integer = quotient;
 
    // condition at end so that zero maps to "0" rather than "".
  } while (integer != 0);
 
  // Reverse the digits (and only the digits) to get the correct
  // order.
  reverse(str.begin() + initialLength, str.end());
}
 
void FrobbyStringStream::appendIntegerToString(string& str,
                                               const mpz_class& integer) {
  str += integer.get_str();
}
 
void FrobbyStringStream::parseInteger(mpz_class& integer, const string& str) {
  if (integer.set_str(str, 10) != 0)
    throw NotAnIntegerException
      ("Argument to FrobbyStringStream::parseInteger not a valid integer.");
}
 
FrobbyStringStream::NotAnIntegerException::NotAnIntegerException
(const string& str):
  runtime_error(str) {
}