util_functions.hpp

Go to the documentation of this file.

//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************


#ifndef __util_functions_hpp__
#define __util_functions_hpp__

#include <vector>
#include <chrono>
#include <cmath>

#include "gambit/Utils/util_types.hpp"
#include "gambit/cmake/cmake_variables.hpp"

#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>

extern "C"
{
  #include "mkpath/mkpath.h"
}

namespace Gambit
{

  template <typename T>
  T byVal(T t) { return t; }

  template <typename T>
  int sgn(T val) { return (T(0) < val) - (val < T(0)); }

  using std::abs;

  template<typename T>
  uintptr_t memaddress_to_uint(T* ptr)
  {
    return reinterpret_cast<uintptr_t>(ptr);
  }

  namespace Utils
  {

    const str buildtime_scratch = GAMBIT_DIR "/scratch/build_time/";

    EXPORT_SYMBOLS const str& runtime_scratch();

    EXPORT_SYMBOLS str construct_runtime_scratch(bool fail_on_mpi_uninitialised=true);

    EXPORT_SYMBOLS std::vector<str> delimiterSplit(str s, str delim);

    EXPORT_SYMBOLS str strip_leading_namespace(str s, str ns);

    EXPORT_SYMBOLS str replace_leading_namespace(str s, str ns, str ns_new);

    EXPORT_SYMBOLS void strip_whitespace_except_after_const(str&);

    EXPORT_SYMBOLS void strip_parentheses(str&);

    EXPORT_SYMBOLS bool sspairset_contains(const str&, const std::set<sspair>&);

    EXPORT_SYMBOLS bool sspairset_contains(const str&, const str&, const std::set<sspair>&);

    EXPORT_SYMBOLS bool sspairset_contains(const sspair&, const std::set<sspair>&);

    EXPORT_SYMBOLS str str_fixed_len(str, int);

    EXPORT_SYMBOLS void strcpy2f(char*, int, str);

    EXPORT_SYMBOLS bool endsWith(const std::string& str, const std::string& suffix);

    EXPORT_SYMBOLS bool startsWith(const std::string& str, const std::string& prefix, bool case_sensitive=true);

    EXPORT_SYMBOLS bool iequals(const std::string& a, const std::string& b, bool case_sensitive=false);

    EXPORT_SYMBOLS std::vector<std::string> split(const std::string& input, const std::string& delimiter);
    
    EXPORT_SYMBOLS std::string strtolower(const std::string& a);
 
    /************************************************************************/
    /* Comparator for case-insensitive comparison in STL assos. containers  */
    /************************************************************************/
    // From: https://stackoverflow.com/a/1801913/1447953
    struct EXPORT_SYMBOLS ci_less : std::binary_function<std::string, std::string, bool>
    {
      // case-independent (ci) compare_less binary function
      struct nocase_compare : public std::binary_function<unsigned char,unsigned char,bool>
      {
        bool operator() (const unsigned char& c1, const unsigned char& c2) const {
            return tolower (c1) < tolower (c2);
        }
      };
      bool operator() (const std::string & s1, const std::string & s2) const {
        return std::lexicographical_compare
          (s1.begin (), s1.end (),   // source range
          s2.begin (), s2.end (),   // dest range
          nocase_compare ());  // comparison
      }
    };


    // Useful for initialising vectors with arrays, e.g.
    //   int vv[] = { 12,43 };
    //   std::vector<int> v(beginA(vv), endA(vv));
    // Though 'begin' is unnecessary, can just do
    //   std::vector<int> v(vv, endA(vv));
    template <typename T, size_t N>
    T* beginA(T(&arr)[N]) { return &arr[0]; }
    template <typename T, size_t N>
    T* endA(T(&arr)[N]) { return &arr[0]+N; }

    // From http://stackoverflow.com/questions/1964150/c-test-if-2-sets-are-disjoint
    template<class Set1, class Set2>
    bool is_disjoint(const Set1 &set1, const Set2 &set2)
    {
      if(set1.empty() || set2.empty()) return true;

      typename Set1::const_iterator
          it1 = set1.begin(),
          it1End = set1.end();
      typename Set2::const_iterator
          it2 = set2.begin(),
          it2End = set2.end();

      if(*it1 > *set2.rbegin() || *it2 > *set1.rbegin()) return true;

      while(it1 != it1End && it2 != it2End)
      {
          if(*it1 == *it2) return false;
          if(*it1 < *it2) { it1++; }
          else { it2++; }
      }

      return true;
    }

    EXPORT_SYMBOLS const str& ensure_path_exists(const str&);

    EXPORT_SYMBOLS bool file_exists(const std::string& filename);

    EXPORT_SYMBOLS std::vector<str> ls_dir(const str& dir);

    EXPORT_SYMBOLS str dir_name(const str& path);

    EXPORT_SYMBOLS str base_name(const str& path);

    EXPORT_SYMBOLS int remove_all_files_in(const str& dirname, bool error_if_absent = true);


    typedef std::chrono::time_point<std::chrono::system_clock> time_point;

    EXPORT_SYMBOLS time_point get_clock_now();

    EXPORT_SYMBOLS str return_time_and_date(const time_point& in);

    EXPORT_SYMBOLS bool are_similar(const str& s1, const str& s2);

    bool check1(const str& s1, const str& s2);

    bool check2(const str& s1, const str& s2);

    EXPORT_SYMBOLS double sqr(double a);

    using std::isnan;

    using std::isinf;

    EXPORT_SYMBOLS bool isInteger(const std::string&);

    template <typename T> int sgn(T val) {  return (T(0) < val) - (val < T(0)); }

    // Dummy functions for variadic variables to avoid compiler warnings
    template<typename... T> void dummy_function() {}
    template<typename T> void dummy_function(T one)
    {
      (void)one;
    }

    template<typename T1, typename... T> void dummy_function(T1 first, T... args)
    {
     (void)first;
     dummy_function(args...);
    }

  }

}

#endif //defined __util_functions_hpp__