utility.h

Go to the documentation of this file.

#ifndef _theplu_yat_utility_utility_
#define _theplu_yat_utility_utility_

// $Id: utility.h 3575 2017-01-12 23:10:47Z 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, 2013, 2014, 2015, 2016 Peter Johansson
  Copyright (C) 2017 Jari Häkkinen

  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 "concept_check.h"
#include "deprecate.h"
#include "Exception.h"
#include "iterator_traits.h"
#include "WeightIterator.h"
#include "yat_assert.h"

#include <gsl/gsl_math.h>

#include <boost/iterator/iterator_concepts.hpp>
#include <boost/concept_check.hpp>

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

namespace theplu {
namespace yat {
namespace utility {

  std::string basename(const std::string& fn);

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

  void chdir(const std::string& dir);

  void chmod(const std::string& filename, mode_t mode);

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

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

  void copy_file(const std::string& source, const std::string& target);


  std::string dirname(const std::string& fn);

  bool fnmatch(const std::string& pattern, const std::string& str,
               int flags=0);

  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');

  // c++11 provides std::log2 so perhaps we should call that one if
  // availalable (but a bit tricky since this is a public header)
  template<typename T>
  T log2(T x) { return std::log(x)/M_LN2; }

  void mkdir(const std::string& dir, mode_t mode=0777);

  void mkdir_p(const std::string& dir, mode_t mode=0777);

  void remove(const std::string& fn);

  void rename(const std::string& from, const std::string& to);

  void replace(std::string& full_str, std::string old_str, std::string new_str);


  template<typename Iterator>
  double sum_weight(Iterator first, Iterator last);


// 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);
    }
  };


  template<typename Iterator>
  double sum_weight(Iterator first, Iterator last, unweighted_iterator_tag tag)
  {
    return std::distance(first, last);
  }


  template<typename Iterator>
  double sum_weight(Iterator first, Iterator last, weighted_iterator_tag tag)
  {
    return std::accumulate(weight_iterator(first), weight_iterator(last), 0);
  }


} // end of namespace detail


  // template implementations

  template<typename InputIterator, typename OutputIterator>
  bool binary_weight(InputIterator first, InputIterator last, 
                     OutputIterator result)
  {
    BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<InputIterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<InputIterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::IncrementableIterator<OutputIterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::WritableIterator<OutputIterator, float>));

    bool nan=false;
    while (first!=last) {
      if (std::isnan(*first)) {
        *result=0;
        nan=true;
      }
      else
        *result = 1.0;
      ++first;
      ++result;
    }
    return nan;
  }


  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).fail();
      else
        ok=!getline(is, element, sep).fail();
      if(!ok)
        break;
      pusher(element, vec);
    }
  }


  template<typename Iterator>
  double sum_weight(Iterator first, Iterator last)
  {
    BOOST_CONCEPT_ASSERT((DataIteratorConcept<Iterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::ReadableIterator<Iterator>));
    BOOST_CONCEPT_ASSERT((boost_concepts::SinglePassIterator<Iterator>));
    typename weighted_iterator_traits<Iterator>::type tag;
    return detail::sum_weight(first, last, tag);
  }


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) || is_equal(s, "-nan")) {
        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