utility.h

Go to the documentation of this file.

#ifndef _theplu_yat_utility_utility_
#define _theplu_yat_utility_utility_

// $Id: utility.h 4262 2023-01-10 00:05:51Z 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, 2020, 2021, 2022 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 <boost/iterator/iterator_concepts.hpp>
#include <boost/concept_check.hpp>

#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdlib>
#include <cstring>
#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 T>
  std::istream& binary_read(std::istream& is, T& x)
  {
    const unsigned char type_size=sizeof(T);
    YAT_ASSERT(type_size <= 16);
    char buffer[16];
    is.read(buffer, type_size);
    memcpy(&x, buffer, type_size);
    return is;
  }


  template<typename T>
  void binary_write(std::ostream& os, T x)
  {
    const unsigned char type_size=sizeof(T);
    YAT_ASSERT(type_size <= 16);
    char buffer[16];
    memcpy(buffer, &x, type_size);
    os.write(buffer, type_size);
  }

  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 charT, class Traits, class Allocator>
  bool contains(const std::basic_string<charT, Traits, Allocator>& str,
                const std::basic_string<charT, Traits, Allocator>& substr);

  template<typename charT, class Traits, class Allocator>
  bool contains(const std::basic_string<charT, Traits, Allocator>& str,
                charT substr);

  template<typename charT, class Traits, class Allocator>
  bool contains(const std::basic_string<charT, Traits, Allocator>& str,
                const charT* substr);


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

  template<typename charT, class Traits, class Allocator>
  bool ends_with(const std::basic_string<charT, Traits, Allocator>& str,
                 const std::basic_string<charT, Traits, Allocator>& suffix);

  template<typename charT, class Traits, class Allocator>
  bool ends_with(const std::basic_string<charT, Traits, Allocator>& str,
                 charT suffix);

  template<typename charT, class Traits, class Allocator>
  bool ends_with(const std::basic_string<charT, Traits, Allocator>& str,
                 const charT* suffix);

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

  std::string getcwd(void);

  void gsl_error_handler(const char* reason, const char* file,
                         int line, int gsl_errno);

  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>
  T log2(T x) { return std::log2(x); }

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

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

#define YAT_MOVE(arg) std::move(arg)
#define YAT_MOVE_IF_NOEXCEPT(arg) std::move_if_noexcept(arg)

  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, const std::string& old_str,
               const std::string& new_str);


  template<typename charT, class Traits, class Allocator>
  bool starts_with(const std::basic_string<charT, Traits, Allocator>& str,
                   const std::basic_string<charT, Traits, Allocator>& prefix);

  template<typename charT, class Traits, class Allocator>
  bool starts_with(const std::basic_string<charT, Traits, Allocator>& str,
                   charT prefix);

  template<typename charT, class Traits, class Allocator>
  bool starts_with(const std::basic_string<charT, Traits, Allocator>& str,
                   const charT* prefix);

  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(convert<T>(element));
      }
    }
  };

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

    void operator()(std::string&& element, std::vector<std::string>& vec)
    {
      vec.push_back(std::move(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 charT, class Traits, class Allocator>
  bool contains(const std::basic_string<charT, Traits, Allocator>& str,
                const std::basic_string<charT, Traits, Allocator>& substr)
  {
#ifdef YAT_HAVE_FUNC_STRING_CONTAINS
    return str.contains(substr);
#else
    return str.find(substr)!=std::basic_string<charT, Traits,Allocator>::npos;
#endif
  }


  template<typename charT, class Traits, class Allocator>
  bool contains(const std::basic_string<charT, Traits, Allocator>& str,
                charT substr)
  {
#ifdef YAT_HAVE_FUNC_STRING_CONTAINS
    return str.contains(substr);
#else
    return str.find(substr)!=std::basic_string<charT, Traits,Allocator>::npos;
#endif
  }


  template<typename charT, class Traits, class Allocator>
  bool contains(const std::basic_string<charT, Traits, Allocator>& str,
                const charT* substr)
  {
#ifdef YAT_HAVE_FUNC_STRING_CONTAINS
    return str.contains(substr);
#else
    return str.find(substr)!=std::basic_string<charT, Traits,Allocator>::npos;
#endif
  }


  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 charT, class Traits, class Allocator>
  bool ends_with(const std::basic_string<charT, Traits, Allocator>& str,
                 const std::basic_string<charT, Traits, Allocator>& suffix)
  {
#ifdef YAT_HAVE_FUNC_STRING_ENDS_WITH
    return str.ends_with(suffix);
#else
    size_t n = suffix.size();
    return n <= str.size() && !str.compare(str.size()-n, n, suffix);
#endif
  }


  template<typename charT, class Traits, class Allocator>
  bool ends_with(const std::basic_string<charT, Traits, Allocator>& str,
                 charT suffix)
  {
#ifdef YAT_HAVE_FUNC_STRING_ENDS_WITH
    return str.ends_with(suffix);
#else
    Traits traits;
    return str.size() && traits.eq(str.back(), suffix);
#endif
  }


  template<typename charT, class Traits, class Allocator>
  bool ends_with(const std::basic_string<charT, Traits, Allocator>& str,
                 const charT* suffix)
  {
#ifdef YAT_HAVE_FUNC_STRING_ENDS_WITH
    return str.ends_with(suffix);
#else
    Traits traits;
    size_t n = traits.length(suffix);
    return n <= str.size() && !str.compare(str.size()-n, n, suffix);
#endif
  }


  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;
      std::vector<T> v;
      v.reserve(nof_columns);
      bool empty_last_element = !line.empty() && line.back()==sep;
      std::stringstream ss(std::move(line));
      load(ss, v, sep);
      // add NaN for final separator (or empty string if T=std::string)
      detail::VectorPusher<T> pusher;
      if (empty_last_element && sep!='\0')
        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());
      matrix.push_back(std::move(v));
    }

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


  template<typename charT, class Traits, class Allocator>
  bool starts_with(const std::basic_string<charT, Traits, Allocator>& str,
                   const std::basic_string<charT, Traits, Allocator>& prefix)
  {
#ifdef YAT_HAVE_FUNC_STRING_STARTS_WITH
    return str.starts_with(prefix);
#else
    size_t n = prefix.size();
    return n <= str.size() && !str.compare(0, n, prefix);
#endif
  }


  template<typename charT, class Traits, class Allocator>
  bool starts_with(const std::basic_string<charT, Traits, Allocator>& str,
                   charT prefix)
  {
#ifdef YAT_HAVE_FUNC_STRING_STARTS_WITH
    return str.starts_with(prefix);
#else
    Traits traits;
    return str.size() && traits.eq(str[0], prefix);
#endif
  }


  template<typename charT, class Traits, class Allocator>
  bool starts_with(const std::basic_string<charT, Traits, Allocator>& str,
                   const charT* prefix)
  {
#ifdef YAT_HAVE_FUNC_STRING_STARTS_WITH
    return str.starts_with(prefix);
#else
    Traits traits;
    size_t n = traits.length(prefix);
    return n <= str.size() && !str.compare(0, n, prefix);
#endif
  }


  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