util.h

Go to the documentation of this file.

#ifndef MUTILS_UTIL_H
#define MUTILS_UTIL_H

#include "mutils/platform.h"

#ifdef __cplusplus
#  include <cctype>
#  include <cstdint>
#  include <cstdlib>

#  include <algorithm>
#  include <map>
#  include <vector>

#include <mutils/Exception.h>
#else
#  include <ctype.h>
#  include <stdio.h>
#  include <stdlib.h>
#  include <string.h>
#endif

#ifdef mu_os_mswin
#  if !defined(strcasecmp)
#    define strcasecmp  stricmp
#    define strncasecmp strnicmp
#  endif
#else
#  include <strings.h>
#  include <unistd.h>
#endif

#define MU_VERMAX  32 /* Max length of version string. */
#define MU_DATEMAX 24 /* Max length of cppdate string. */

#ifdef __cplusplus
extern "C" {
#endif

DLLSPEC extern void
  mu_cppdate(char str[ /*MU_DATEMAX*/ ], const char *date, const char *time),
  mu_error_action(int, const char *, const char *, int, int),
  mu_split_tag(char pre[], int *maj, int *min, int *clas, int *bug,
    int *y, int *m, int *d, const char *tag);

DLLSPEC extern char
 *mu_utoa9(char *str, unsigned i, int strip),
 *mu_fgetline(char *, long int, FILE *);

DLLSPEC extern const char
 *mu_platform(void),
 *mu_version(void),
 *mu_verstr(char verstr[ /*MU_VERMAX*/ ], const char *pre,
            int maj, int min, int clas, int bug);

DLLSPEC extern int
  mu_ppmtext(char *, char *, int, int, int),
  mu_vernum(const char *name, const char *cvs);

#define MU_iferr_abort(err, func)  do { \
  if (err) mu_error_action(-1, func, __FILE__, __LINE__, -1); } while (0)

#define MU_iferr_warn(err, func)  do { \
  if (err) mu_error_action(-1, func, __FILE__, __LINE__,  0); } while (0)

#define MU_iferr(err, func)  do { \
  if (err) mu_error_action(-1, func, __FILE__, __LINE__,  1); } while (0)

#define MU_iferrn_abort(err, func)  do { \
  int errn=(err); \
  if (errn) mu_error_action(errn, func, __FILE__, __LINE__, -1); } while (0)

#define MU_iferrn_warn(err, func)  do { \
  int errn=(err); \
  if (errn) mu_error_action(errn, func, __FILE__, __LINE__,  0); } while (0)

#define MU_iferrn(err, func)  do { \
  int errn=(err); \
  if (errn) mu_error_action(errn, func, __FILE__, __LINE__,  1); } while (0)

#define mu_alloc(s)      mu_alloc_r(NULL, s)
#define mu_realloc(p, s) mu_realloc_r(NULL, p, s)
#define mu_free(p)       mu_free_r(NULL, p)
#define mu_freeall()     mu_freeall_r(NULL)

DLLSPEC extern int mu_free_r(void **, void *);
DLLSPEC extern void
   mu_freeall_r(void *), *mu_alloc_r(void **, size_t),
  *mu_realloc_r(void **, void *, size_t);


DLLSPEC extern int  mu_clock_Hz(void);
DLLSPEC extern void mu_wait_time(double);
DLLSPEC extern double
  mu_clock_time(void), mu_real_clock_time(void),
  mu_cpu_time(void), mu_system_time(void), mu_user_time(void),
  mu_process_cpu_time(void), mu_thread_cpu_time(void);


DLLSPEC extern char *mu_optarg;
DLLSPEC extern int
  mu_opterr, mu_optind, mu_optopt,
  mu_getopt(int argc, char * const argv[], const char *opts);

DLLSPEC extern double
  mu_time_unary(double (*fn)(double), double x1, double x2, double tmin);

DLLSPEC extern double
  mu_time_binary(double (*fn)(double, double), double x1,
                 double x2, double y1, double y2, double tmin);

DLLSPEC extern double
  mu_time_trinary(double (*fn)(double, double, double), double x1,
                  double x2, double y1, double y2, double z1, double z2,
                  double tmin);


    /* ============ C++ specific section below here ============ */

#ifdef __cplusplus
}  // extern "C"

namespace mutils {

extern std::string::size_type npos;

extern const std::string nullStr;


extern const std::string siPrefixes;

extern const std::map<char, const char *> siScaleMap;

inline const char *siScale(char siPrefix)
{
  auto p = siScaleMap.find(siPrefix);
  return (p != siScaleMap.end() ? p->second : "NaN");
}

inline bool siHasPrefix(const std::string &unit,
                        const std::vector<std::string> &baseUnits)
{
  for (auto &base: baseUnits) { if (base == unit) { return false; } }
  if (siPrefixes.find_first_of(unit.front()) != npos) {
    for (auto &base: baseUnits) { if (base == &unit[1]) { return true; } }
  }
  return false;
}


extern int readLogicalLine(std::string &line, FILE *file,
                           unsigned *nLines = nullptr,
                           const char *eol = "\r\n");


template<typename C, typename I = typename C::const_iterator>
const typename C::value_type &getValue(I p)
{
  return *p;
}

template<typename C, typename I = typename C::const_iterator>
const typename C::key_type &getKey(I p)
{
  return p->first;
}

template<typename C, typename I = typename C::const_iterator>
const typename C::mapped_type &getMapped(I p)
{
  return p->second;
}

inline int strMatch(const std::string &s1, const std::string &s2,
                    std::string::size_type minChar = npos,
                    bool caseSense = false)
{
  auto ncmp = (caseSense ? strncmp : strncasecmp);
  auto n = std::min(s1.size(), s2.size());                  // Minimum  match.
  if (n < minChar) { n = std::max(s1.size(), s2.size()); }  // Complete match.
  return ncmp(s1.c_str(), s2.c_str(), n);
}

template<typename C, typename I = typename C::iterator,
         const std::string &(*F)(I) = getValue<C, I>>
std::vector<I> findMatch(const std::string &s, C &pool,
                 std::string::size_type minChar = npos, bool caseSense = false)
{
  std::vector<I> rtn;
  for (I p = pool.begin(); p != pool.end(); ++p) {
    if (strMatch(s, F(p), minChar, caseSense) == 0) { rtn.push_back(p); }
  }
  return rtn;
}

template<typename C, typename I = typename C::iterator,
         const std::string &(*F)(I) = getKey<C, I>>
I findUnique(const std::string &str, C &pool,
             std::string::size_type minChar = npos, bool caseSense = false)
{
  const char *fn = "util::findUnique";
  auto matches = findMatch<C, I, F>(str, pool, minChar, caseSense);
  std::string matchNames;
  for (auto p: matches) {
    matchNames += "  ";
    matchNames += F(p);
  }
  MU_EXCEPTION_IF(matches.size() > 1, fn,
                  "Multiple matches found for '%s':\n%s", str, matchNames);

  return (matches.empty() ? pool.end() : matches[0]);
}


template<typename R, typename S, typename T, typename... Args>
inline typename
  std::enable_if<std::is_member_function_pointer<S>::value, R>::type
fn_call(S s, T &t, Args&&... args) { return (t.*s)(args...); }

template<typename R, typename S, typename T, typename... Args>
inline typename
  std::enable_if<!std::is_member_function_pointer<S>::value, R>::type
fn_call(S s, T &t, Args&&... args) { return s(t, args...); }


inline
std::string qualifyPath(const std::string &path, const std::string &file)
{
  std::string rtn;
  if (path != nullStr && file != nullStr) {
    if (!path.empty() && !file.empty() && file[0] != '/'
                      && file != "-" && file != "!") {
      rtn = path;
      if (path.back() != '/') { rtn += '/'; }
    }
    rtn += file;
  } else {
    rtn = nullStr;
  }
  return rtn;
}

inline
std::string getToken(const std::string &line, size_t *index = nullptr)
{
  const std::string white{" \t\r\n"};
  size_t i0 = line.find_first_not_of(white, (index ? *index : 0UL)),
         i1 = line.find_first_of(white, i0);
  if (index) { *index = i1; }
  return (i0 != npos ? line.substr(i0, i1-i0) : "");
}

}  // namespace mutils
#endif  /* __cplusplus */

#endif  /* MUTILS_UTIL_H */