utility.h

Go to the documentation of this file.

#ifndef _theplu_yat_utility_utility_
#define _theplu_yat_utility_utility_ 

// $Id: utility.h 2820 2012-08-30 00:47:58Z peter $

/*
  Copyright (C) 2005 Jari Häkkinen, Peter Johansson, Markus Ringnér
  Copyright (C) 2006 Jari Häkkinen
  Copyright (C) 2007, 2008 Jari Häkkinen, Peter Johansson
  Copyright (C) 2009, 2010, 2011, 2012 Peter Johansson

  This file is part of the yat library, http://dev.thep.lu.se/yat

  The yat library 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 3 of the
  License, or (at your option) any later version.

  The yat library 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/


#include "deprecate.h"
#include "Exception.h"
#include "yat_assert.h"

#include <algorithm>
#include <cctype>
#include <cmath>
#include <functional>
#include <limits>
#include <locale>
#include <istream>
#include <string>
#include <stdexcept>
#include <sstream>
#include <utility>
#include <vector>

namespace theplu {
namespace yat {
namespace utility {

  template<typename InputIterator, typename OutputIterator>
  bool binary_weight(InputIterator first, InputIterator last, 
                     OutputIterator result);

  template<typename T>
  std::string convert(T input);

  template<typename T>
  T convert(const std::string& s);

  template<typename T>
  bool is(const std::string& s);

  bool is_double(const std::string&) YAT_DEPRECATE;

  bool is_equal(std::string s, std::string other);

  bool is_float(const std::string&) YAT_DEPRECATE;

  bool is_int(const std::string&) YAT_DEPRECATE;

  bool is_nan(const std::string& s);

  template<typename T>
  void load(std::istream& is, std::vector<std::vector<T> >& vec, char sep='\0', 
            char line_sep='\n', bool ignore_empty=false, bool rectangle=true);

  template<typename T>
  void load(std::istream& is, std::vector<T>& vec, char sep='\0');
  
// private namespace
namespace detail {

  template<typename T>
  bool convert(const std::string& s, T& t);

  template<typename T>
  struct VectorPusher
  {
    void operator()(const std::string& element, std::vector<T>& vec)
    { 
      if (!element.size())
        vec.push_back(std::numeric_limits<T>::quiet_NaN());
      else {
        vec.push_back(theplu::yat::utility::convert<T>(element));
      }
    }
  };

  template<>
  struct VectorPusher<std::string>
  {
    void operator()(const std::string& element, std::vector<std::string>& vec)
    { 
      vec.push_back(element);
    }
  };

} // end of namespace detail


  // template implementations

  template<typename InputIterator, typename OutputIterator>
  bool binary_weight(InputIterator first, InputIterator last, 
                     OutputIterator result)
  {
    bool nan=false;
    while (first!=last) {
      if (std::isnan(*first)) {
        *result=0;
        nan=true;
      }
      else
        *result = 1.0;
      ++first;
      ++result;
    }
    return nan;
  }


  // template implementations
  template<typename T>
  std::string convert(T input)
  {
    std::ostringstream ss;
    ss << input;
    return ss.str();
  }


  template<typename T>
  T convert(const std::string& s)
  {
    T result;
    if (!detail::convert(s, result))
      throw runtime_error(std::string("yat::utility::convert(\"")+s+
                          std::string("\")"));
    return result;
  }


  template<typename T>
  bool is(const std::string& s)
  {
    T tmp;
    return detail::convert(s, tmp);
  }


  template<typename T>
  void load(std::istream& is, std::vector<std::vector<T> >& matrix, 
            char sep, char line_sep, bool ignore_empty, 
            bool rectangle)
  {
    size_t nof_columns=0;
    std::string line;
    while(getline(is, line, line_sep)){
      if (line.empty() && ignore_empty)
        continue;
      matrix.push_back(std::vector<T>());
      std::vector<T>& v=matrix.back();
      v.reserve(nof_columns);
      std::stringstream ss(line);
      load(ss, v, sep);
      // add NaN for final separator (or empty string if T=std::string)
      detail::VectorPusher<T> pusher;
      if(sep!='\0' && !line.empty() && line[line.size()-1]==sep) 
        pusher("", v);
      
      if (rectangle && nof_columns && v.size()!=nof_columns) {
        std::ostringstream s;
        s << "load stream error: "
          << "line " << matrix.size() << " has " << v.size()
          << " columns; expected " << nof_columns << " columns.";
        throw utility::IO_error(s.str());
      }       
      nof_columns = std::max(nof_columns, v.size());
    }

    // manipulate the state of the stream to be good
    is.clear(std::ios::goodbit);
  }

  template<typename T>
  void load(std::istream& is, std::vector<T>& vec, char sep)
  {
    detail::VectorPusher<T> pusher;
    std::string element;
    bool ok=true;
    while(true) {
      if(sep=='\0')
        ok=(is>>element);
      else
        ok=getline(is, element, sep);
      if(!ok)
        break;
      pusher(element, vec);
    }
  }           


namespace detail {
  template<typename T>
  bool convert(const std::string& s, T& result)
  {
    if (!std::numeric_limits<T>::is_signed) {
      // first non-whitespace character
      std::string::const_iterator iter = s.begin();
      while (iter!=s.end() && std::isspace(*iter))
        ++iter;
      // unsigned int cannot start with a '-' and with some compilers
      // operation ss >> result won't fail so catch it like this instead.
      if (iter==s.end() || *iter=='-')
        return false;
    }
    std::istringstream ss(s);
    ss >> result;
    if (ss.fail()) {
      if (is_nan(s)) {
        result = std::numeric_limits<T>::quiet_NaN();
        return true;
      }
      if (is_equal(s, "inf")) {
        result = std::numeric_limits<T>::infinity();
        return true;
      }
      if (is_equal(s, "-inf")) {
        // unsigned types are caught in prologue
        YAT_ASSERT(std::numeric_limits<T>::is_signed);
        result = -std::numeric_limits<T>::infinity();
        return true;
      }
      return false;
    }
    // Check that nothing is left on stream
    std::string b;
    ss >> b;
    return b.empty();
  }
} // of namespace detail

}}} // of namespace utility, yat, and theplu

#endif