Utilities.h

Go to the documentation of this file.

#ifndef AMPGEN_UTILITIES_H
#define AMPGEN_UTILITIES_H
 
#include <cxxabi.h>
#include <stddef.h>
#include <algorithm>
#include <fstream>
#include <functional>
#include <map>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
#include <future>
#ifdef _OPENMP
#include <omp.h>
#endif
 
#include "AmpGen/MsgService.h"
#include "AmpGen/MetaUtils.h"
 
namespace AmpGen {
  template <typename iterator_type, typename functor_type>
  std::string vectorToString(iterator_type begin, iterator_type end, const std::string &delim, functor_type fcn) {
    std::stringstream ss;
    if(begin == end) return "";
    for(auto it = begin; it != end - 1; ++it) ss << fcn(*it) << delim;
    ss << fcn(*(end - 1));
    return ss.str();
  }
 
  template <typename tuple_t> std::string tupleToString(const tuple_t &tuple, const std::string &delim) {
    std::stringstream ss;
    for_each(tuple, [&ss, delim](auto &item) { ss << item << delim; });
    return ss.str();
  }
 
  template <typename container_type, typename vtype = typename container_type::value_type, typename functor_type = std::function<vtype(const vtype &)>>
  std::string vectorToString(const container_type &obj, const std::string &delim = "", const functor_type &f = [](const auto &arg) { return arg; }) {
    return vectorToString(std::begin(obj), std::end(obj), delim, f);
  }
 
  template <typename T> std::vector<std::vector<T>> nCr(const T &n, const T &r) {
    std::vector<bool> mask(n);
    std::vector<std::vector<T>> combinations;
    std::fill(mask.begin() + r, mask.end(), true);
    do {
      std::vector<T> perm;
      for(T i = 0; i < n; ++i)
        if(!mask[i]) perm.push_back(i);
      combinations.push_back(perm);
    } while(std::next_permutation(mask.begin(), mask.end()));
    return combinations;
  }
 
  std::vector<std::string> vectorFromFile(const std::string &filename, const char ignoreLinesThatBeginWith = '#');
 
  std::vector<std::string> split(const std::string &, char, bool = true);
  std::vector<std::string> split(const std::string &, const std::vector<char> &, bool = false);
 
  std::vector<size_t> findAll(const std::string &input, const std::string &ch);
 
  std::map<size_t, std::string> vecFindAll(const std::string &input, const std::vector<std::string> &vCh);
 
  size_t find_next_of(const std::string &input, const std::vector<std::string> &patterns, const size_t &begin = 0);
 
  std::string replaceAll(const std::string &input, const std::string &toReplace, const std::string &replaceWith);
  std::string replaceAll(const std::string &input, const std::vector<std::pair<std::string, std::string>> &rules);
 
  unsigned int FNV1a_hash(const std::string &toHash);
 
  std::vector<std::string> getItems(const std::string &tree, const std::vector<std::string> &brackets = {"{", "}"}, const std::string &seperator = ",");
 
  void swapChars(std::string &arg, const char a, const char b);
 
  unsigned int editDistance(const std::string &s1, const std::string &s2);
 
  std::string round(const double &number, const unsigned int &nsf);
 
  std::string numberWithError(const double &number, const double &error, const unsigned int &nDigits);
 
  template <typename return_type> return_type lexical_cast(const std::string &word, bool &status);
 
  /*
{
  WARNING("Only use specialised versions of this template (word = " << word << ", type = " << AmpGen::type_string<return_type>() << ")  ");
  status = 0;
  return return_type();
}
*/
  template <class... ARGS> std::string mysprintf(const std::string &format, ARGS &&...args) {
    auto size = std::snprintf(nullptr, 0, format.c_str(), std::forward<ARGS>(args)...);
    std::string output(size + 1, '\0');
    std::snprintf(&output[0], size + 1, format.c_str(), std::forward<ARGS>(args)...);
    return output.substr(0, output.size() - 1);
  }
 
  template <> double lexical_cast(const std::string &word, bool &status);
  template <> unsigned int lexical_cast(const std::string &word, bool &status);
  template <> std::string lexical_cast(const std::string &word, bool &status);
  template <> float lexical_cast(const std::string &word, bool &status);
  template <> bool lexical_cast(const std::string &word, bool &status);
  template <> int lexical_cast(const std::string &word, bool &status);
  template <> unsigned long int lexical_cast(const std::string &word, bool &status);
  template <> long int lexical_cast(const std::string &word, bool &status);
 
  template <typename functor_type> void processFile(const std::string &filename, functor_type &&toDo, const char ignoreLinesThatBeginWith = '#') {
    std::string tmp;
    std::ifstream inFile(filename.c_str());
    while(inFile.good()) {
      std::getline(inFile, tmp);
      tmp.erase(std::remove_if(tmp.begin(), tmp.end(), [](const char c) { return c == '\r'; }), tmp.end());
      if(ignoreLinesThatBeginWith != '\0' && (tmp.size() == 0 || tmp[0] == ignoreLinesThatBeginWith)) continue;
      toDo(tmp);
    }
    inFile.close();
  }
 
  // calculate number of swaps required to reorder set, where swaps can have different exchange parities.
  std::pair<size_t, int> minSwaps(const std::vector<size_t> &indices, const std::vector<int> &exchangeParities);
 
  template <class iterator, class comparator> void parallel_sort(iterator begin, iterator end, const comparator &comp, const size_t &grainsize) {
    const size_t len = end - begin;
    if(len < grainsize)
      std::sort(begin, end, comp);
    else {
      const auto middle = begin + len / 2;
      auto future = std::async(parallel_sort<iterator, comparator>, begin, middle, comp, grainsize);
      parallel_sort(middle, end, comp, grainsize);
      future.wait();
      std::inplace_merge(begin, middle, end, comp);
    }
  }
 
  template <class iterator, class initial_value, class functor>
  initial_value parallel_accumulate(iterator begin, iterator end, const initial_value &init, const functor &f) {
    auto total = init;
    auto size = end - begin;
#ifdef _OPENMP
#pragma omp parallel for reduction(+ : total)
#endif
    for(int it = 0; it < size; ++it) { total += f(*(begin + it)); }
    return total;
  }
  template <typename return_type, typename contained_type>
  std::function<return_type(const contained_type &)> arrayToFunctor(const std::vector<return_type> &values) {
    return [values](const contained_type &event) -> return_type { return *(values.data() + event.index()); };
  }
 
  template <typename T> std::vector<std::vector<T>> all_combinations(const std::vector<std::vector<T>> &elements) {
    int nc = 1;
    for(const auto &s : elements) nc *= s.size();
    std::vector<std::vector<T>> comb(nc, std::vector<T>(elements.size(), 0));
    for(int i = 0; i != comb.size(); ++i) {
      int counter = i;
      for(int j = elements.size() - 1; j >= 0; --j) {
        int t = counter % elements[j].size();
        counter = (counter - t) / elements[j].size();
        comb[i][j] = elements[j][t];
      }
    }
    return comb;
  }
 
  template <class iterator> void parallel_sort(iterator begin, iterator end, const size_t &grainsize) {
    typedef typename std::iterator_traits<iterator>::value_type value_type;
    parallel_sort(begin, end, std::less<value_type>(), grainsize);
  }
 
  bool stringMatchesWildcard(const std::string &input, const std::string &wildcard_string, const char wildcard_character = '*');
 
  bool isDir(const std::string &fname);
  bool fileExists(const std::string &name);
 
  std::vector<std::string> getListOfFiles(const std::string &directory, const std::string &patternString = "");
 
  void printSplash();
  void printReleaseNotes(const std::string &fname);
 
  std::string ltrim(std::string s);
  std::string rtrim(std::string s);
  std::string trim(const std::string &s);
  std::string expandGlobals(std::string path);
 
  std::ostream &bold_on(std::ostream &);
  std::ostream &bold_off(std::ostream &);
  std::ostream &italic_on(std::ostream &);
  std::ostream &italic_off(std::ostream &);
}
#endif