Misc.h

Go to the documentation of this file.

 
#ifndef ETISS_INCLUDE_MISC_H_
#define ETISS_INCLUDE_MISC_H_
 
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <mutex>
#include <regex>
#include <set>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
 
#include "etiss/config.h"
 
#include "etiss/jit/types.h"
 
// some msvc pathces
#ifdef _MSC_VER
typedef std::make_signed<size_t>::type ssize_t;
#endif
 
#define ETISS_TOSTRING2(X) #X
#define ETISS_TOSTRING(X) ETISS_TOSTRING2(X)
 
#define etiss_log(LEVEL, MSG) \
    etiss::log(etiss::LEVEL,  \
               std::string("On line " ETISS_TOSTRING(__LINE__) " in file " ETISS_TOSTRING(__FILE__) ": ") + (MSG));
#define etiss_log(LEVEL, MSG) \ …
 
#define etiss_del_copy(CLASS)      \
    CLASS(const CLASS &) = delete; \
    CLASS &operator=(const CLASS &) = delete;
#define etiss_del_copy(CLASS)      \ …
#define etiss_del_move(CLASS)            \
    CLASS &operator=(CLASS &&) = delete; \
    CLASS(CLASS &&) = delete;
#define etiss_del_move(CLASS)            \ …
 
#define etiss_del_como(CLASS) etiss_del_copy(CLASS) etiss_del_move(CLASS)
 
// special define that creates a STRUCT whose STRUCT::value is true if EXPRESSION is valid given template parameter T
// (note expression may not have a ';': e.g. ((T*)0)->toString() NOT ((T*)0)->toString();
#define ETISS_TEMPLATE_EXPRESSION_IS_VALID(STRUCT, EXPRESSION)                           \
    template <typename>                                                                  \
    struct STRUCT##Void                                                                  \
    {                                                                                    \
        typedef void type;                                                               \
    };                                                                                   \
    template <typename T, typename Sfinae = void>                                        \
    struct STRUCT : std::false_type                                                      \
    {                                                                                    \
    };                                                                                   \
    template <typename T>                                                                \
    struct STRUCT<T, typename STRUCT##Void<decltype(EXPRESSION)>::type> : std::true_type \
    {                                                                                    \
    };
#define ETISS_TEMPLATE_EXPRESSION_IS_VALID(STRUCT, EXPRESSION)                           \ …
 
namespace etiss
{
class Configuration;
 
enum Verbosity
{
    SILENT = 0,
    FATALERROR = 1,
    ERROR = 2,
    WARNING = 3,
    INFO = 4,
    VERBOSE = 5
};
enum Verbosity {…};
 
class ToString
{
  public:
    inline ToString() {}
    virtual inline ~ToString() {}
};
class ToString {…};
 
template <typename T>
typename std::enable_if<std::is_base_of<etiss::ToString, T>::value, std::ostream &>::type operator<<(std::ostream &os,
                                                                                                     const T &val)
{
    os << val.toString();
    return os;
}
typename std::enable_if<std::is_base_of<etiss::ToString, T>::value, std::ostream &>::type operator<<(std::ostream &os, {…}
 
Verbosity &verbosity();
 
template <typename T>
std::string toString(const T &val)
{
    std::stringstream ss;
    ss << val;
    return ss.str();
}
std::string toString(const T &val) {…}
 
std::list<std::string> split(
    const std::string &str,
    std::function<size_t(const std::string & , size_t , size_t & )> findsplit);
inline std::list<std::string> split(const std::string &str, char splitchar)
{
    return split(str, [splitchar](const std::string &str, size_t from, size_t &seperatorsize) {
        seperatorsize = 1;
        return str.find(splitchar, from);
    });
}
inline std::list<std::string> split(const std::string &str, char splitchar) {…}
 
inline std::list<std::string> split(const std::string &str, const std::string &splitstring)
{
    return split(str, [splitstring](const std::string &str, size_t from, size_t &seperatorsize) {
        seperatorsize = 1;
        return str.find(splitstring, from);
    });
}
inline std::list<std::string> split(const std::string &str, const std::string &splitstring) {…}
 
template <typename T, typename T2, typename... O>
std::string toString(const T &val, const T2 &val2, const O &... others)
{
    return toString(val) + ";" + toString(val2, others...);
}
std::string toString(const T &val, const T2 &val2, const O &... others) {…}
 
std::string toString(const Verbosity &val);
 
class SourceCodeLocation : public ToString
{
  public:
    inline SourceCodeLocation(const std::string &file, size_t line) : file_(file), line_(line) {}
    inline std::string toString() const
    {
        return std::string("SourceCodeLocation { file=\"") + file_ + "\", line=" + etiss::toString(line_) + "}";
    }
    inline std::string toString() const {…}
    const std::string file_;
    const size_t line_;
};
class SourceCodeLocation : public ToString {…};
 
#define ETISS_SRCLOC etiss::SourceCodeLocation(__FILE__, __LINE__)
#define ETISS_VARVAL(VAR) (std::string(ETISS_TOSTRING(VAR)) + "={" + toLogString(VAR) + "}")
 
void log(Verbosity level, std::string msg);
 
void logC(Verbosity level, std::function<std::string(void)> msgGen);
 
template <typename T>
std::string toLogString(const T &t)
{
    return std::string("{") + etiss::toString(t) + "}";
}
std::string toLogString(const T &t) {…}
 
template <typename T1, typename T2, typename... O>
std::string toLogString(const T1 &t1, const T2 &t2, const O &... os)
{
    return toLogString(t1) + "\n\t\t" + toLogString(t2, os...);
}
std::string toLogString(const T1 &t1, const T2 &t2, const O &... os) {…}
 
template <typename T, typename... O>
void log(Verbosity level, std::string msg, const T &t, const O &... args)
{
    if (level <= (int)verbosity())
    {
        etiss::log(level, msg + " \n\t{\n\t\t" + toLogString(t, args...) + "\n\t}");
    }
}
void log(Verbosity level, std::string msg, const T &t, const O &... args) {…}
 
std::vector<std::string> parseCommands(const std::string &cmdline);
 
Configuration &cfg(const std::string &cfgName);
Configuration &cfg();
 
std::string installDir();
 
std::string jitFiles();
 
std::vector<std::string> jitExtHeaders();
 
std::vector<std::string> jitExtLibraries();
 
std::vector<std::string> jitExtHeaderPaths();
std::vector<std::string> jitExtLibPaths();
 
class Configuration
{
  public:
    Configuration();
    Configuration(std::string args);
    Configuration(const std::list<std::string> &args);
 
    std::map<std::string, std::string> &config();
 
    template <typename T>
    T get(const std::string &key, T default_, bool *default_used = 0)
    {
        etiss::log(etiss::ERROR, std::string("etiss::Configuration::get not implemented for requested type")
                   /* + typeid(T).name()*/);
        if (default_used)
            *default_used = true;
        return default_;
    }
    T get(const std::string &key, T default_, bool *default_used = 0) {…}
 
    bool debug();
 
    template <typename T>
    bool set(const std::string &key, T value)
    {
        // GCC 4.9.0 required:
        /*
        std::regex reModule("(^|::)core[[:digit:]]+::");
        std::smatch match;
        if(std::regex_search(key, match, reModule))
        {
          std::ptrdiff_t const match_count(std::distance(
            std::sregex_iterator(key.begin(), key.end(), reModule),
            std::sregex_iterator()));
          if (match_count > 1)
          {
            etiss::log(etiss::ERROR, std::string("Config key invalid") +
                       " (more than one module specialization) key: " + key);
            return false;
          }
          std::string strReplace = match.str(0).substr(0,2).compare("")?"":"::";
          std::string newkey = key;
          newkey.replace(match.position(0),match.length(0),strReplace);
          std::cout << "new key: " << newkey << std::endl;
          return etiss::cfg(newkey).set<T>(newkey, value);
        }*/
        size_t coreStart = key.find("core");
        size_t coreEnd = key.find("::", coreStart + 1);
        if (coreStart != std::string::npos && coreEnd != std::string::npos &&
            key.substr(coreStart + 4, coreEnd - (coreStart + 4)).find_first_not_of("0123456789") == std::string::npos)
        {
            std::string newkey = key;
            newkey.replace(coreStart, coreEnd - coreStart + 2, "");
            etiss::log(etiss::INFO, std::string("use ") + newkey + " in Configuration for module " +
                                        key.substr(coreStart, coreEnd - coreStart));
            return etiss::cfg(key.substr(coreStart, coreEnd - coreStart)).set<T>(newkey, value);
        }
 
        std::stringstream ss;
        ss << value;
        std::lock_guard<std::mutex> lock(mu_);
        if (final_.find(key) != final_.end())
            return false;
 
        auto hlp = helpers_.find(key);
        if (hlp != helpers_.end())
        {
            cfg_[key] = (hlp->second)(ss.str());
        }
        else
        {
            cfg_[key] = ss.str();
        }
        return true;
    }
    bool set(const std::string &key, T value) {…}
 
    bool isSet(std::string val);
 
    void remove(const std::string &key);
 
    std::list<std::string> set(const std::list<std::string> &args);
 
    static std::pair<std::string, std::string> set_cmd_line_boost(const std::string& s);
 
    std::map<std::string, std::string> listFullConfiguration();
 
    void makeFinal(const std::string &key);
 
    void announce(std::string key, std::string type = std::string(), std::string values = std::string(),
                  std::string description = std::string());
 
    std::map<std::string, std::tuple<std::string, std::string, std::string>> getAnnounced() const;
 
    void operator=(Configuration &&other)
    {
        std::lock_guard<std::mutex> lock(other.mu_);
        std::lock_guard<std::mutex> lock2(mu_);
        cfg_ = other.cfg_;
        final_ = other.final_;
        helpers_ = other.helpers_;
        announced_ = other.announced_;
    }
    void operator=(Configuration &&other) {…}
 
  private:
    std::map<std::string, std::string> cfg_;
    std::set<std::string> final_;
    std::map<std::string, std::function<std::string(std::string)>> helpers_;
    mutable std::mutex mu_;
    std::map<std::string, std::tuple<std::string, std::string, std::string>> announced_;
};
class Configuration {…};
 
// template specializations
template <>
std::string Configuration::get<std::string>(const std::string &key, std::string default_, bool *default_used);
 
template <>
bool Configuration::get<bool>(const std::string &key, bool default_, bool *default_used);
 
template <>
int Configuration::get<int>(const std::string &key, int default_, bool *default_used);
 
template <>
unsigned Configuration::get<unsigned>(const std::string &key, unsigned default_, bool *default_used);
 
template <>
uint64_t Configuration::get<uint64_t>(const std::string &key, uint64_t default_, bool *default_used);
 
class ConfigAnnouncer
{
  public:
    inline ConfigAnnouncer(Configuration &config, std::string key, std::string type = std::string(),
                           std::string values = std::string(), std::string description = std::string())
    {
        config.announce(key, type, values, description);
    }
    inline ConfigAnnouncer(Configuration &config, std::string key, std::string type = std::string(), {…}
 
    inline ConfigAnnouncer(std::string key, std::string type = std::string(), std::string values = std::string(),
                           std::string description = std::string())
    {
        cfg().announce(key, type, values, description);
    }
    inline ConfigAnnouncer(std::string key, std::string type = std::string(), std::string values = std::string(), {…}
};
class ConfigAnnouncer {…};
 
enum endian_t : uint32_t
{
    _LITTLE_ENDIAN_ = ETISS_LITTLE_ENDIAN,
    _BIG_ENDIAN_ = ETISS_BIG_ENDIAN,
    _UNKNOWN_ENDIAN_ = ETISS_UNKNOWN_ENDIAN
};
enum endian_t : uint32_t {…};
 
#if ETISS_USE_CONSTEXPR
constexpr
#else
inline
#endif
    endian_t
    getEndianness()
{
    return ((0xFFFFFFFF & 1) == _LITTLE_ENDIAN_) ? _LITTLE_ENDIAN_
                                                 : ((0xFFFFFFFF & 1) == _BIG_ENDIAN_) ? _BIG_ENDIAN_ : _UNKNOWN_ENDIAN_;
}
    getEndianness() {…}
 
} // end of namespace etiss
 
#include "etiss/ClassDefs.h"
 
#endif