utility.h

Go to the documentation of this file.

#ifndef _theplu_yat_utility_utility_
#define _theplu_yat_utility_utility_

// $Id: utility.h 3855 2020-01-02 01:11:34Z 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, 2017, 2018, 2019 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 "config_public.h"

#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 <iostream>
#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);

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

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

  std::string getcwd(void);

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

  template<typename T>
#ifdef YAT_HAVE_LOG2
  T log2(T x) { return std::log2(x); }
#else
  T log2(T x) { return std::log(x)/M_LN2; }
#endif

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

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

#if YAT_HAVE_RVALUE
#define YAT_MOVE(arg) std::move(arg)
#define YAT_MOVE_IF_NOEXCEPT(arg) std::move_if_noexcept(arg)
#else
#define YAT_MOVE(arg) (arg)
#define YAT_MOVE_IF_NOEXCEPT(arg) (arg)
#endif

  void print_what(const std::exception& error, std::ostream& out=std::cerr);

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

  void symlink(const std::string& path1, const std::string& path2);


// private namespace
namespace detail {

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

#ifdef YAT_HAVE_RVALUE
    void operator()(std::string&& element, std::vector<std::string>& vec)
    {
      vec.push_back(std::move(element));
    }
#endif
  };


  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 (!convert_try(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 convert_try(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;
    bool ok=true;
    while(true) {
      std::string element;
      if(sep=='\0')
        ok=!(is>>element).fail();
      else
        ok=!getline(is, element, sep).fail();
      if(!ok)
        break;
      pusher(YAT_MOVE(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);
  }



  template<typename T>
  bool convert_try(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 utility, yat, and theplu

#endif