common.hpp

Go to the documentation of this file.

#pragma once
// Include most of the C stdlib for convenience
#include <cstddef>
#include <cstdlib>
#include <cstdio>
#include <cstdint>
#include <cinttypes>
#include <cstdarg>
#include <climits>
#include <cmath>
#include <cstring>
#include <cassert>
 
// Include some of the C++ stdlib for convenience
#include <string>
#include <stdexcept>
 
#include <arch.hpp>
 

#define DEPRECATED __attribute__((deprecated))

#ifndef PRIVATE
#define PRIVATE
#endif
 

#define CONCAT_LITERAL(x, y) x ## y
#define CONCAT(x, y) CONCAT_LITERAL(x, y)
 

#define TOSTRING_LITERAL(x) #x
#define TOSTRING(x) TOSTRING_LITERAL(x)
 

#define LENGTHOF(arr) (sizeof(arr) / sizeof((arr)[0]))
 

#define ENUMS(name, count) name, name ## _LAST = name + (count) - 1
 

// Use synbols generated from `xxd -i`
#define BINARY(sym) extern "C" {extern const unsigned char sym[]; extern const unsigned int sym##_len;}
#define BINARY_START(sym) (sym)
#define BINARY_END(sym) (sym + sym##_len)
#define BINARY_SIZE(sym) (sym##_len)
 

inline int8_t operator"" _i8(unsigned long long x) {return x;}
inline int16_t operator"" _i16(unsigned long long x) {return x;}
inline int32_t operator"" _i32(unsigned long long x) {return x;}
inline int64_t operator"" _i64(unsigned long long x) {return x;}
inline uint8_t operator"" _u8(unsigned long long x) {return x;}
inline uint16_t operator"" _u16(unsigned long long x) {return x;}
inline uint32_t operator"" _u32(unsigned long long x) {return x;}
inline uint64_t operator"" _u64(unsigned long long x) {return x;}
inline float operator"" _f32(long double x) {return x;}
inline float operator"" _f32(unsigned long long x) {return x;}
inline double operator"" _f64(long double x) {return x;}
inline double operator"" _f64(unsigned long long x) {return x;}
 
 
#if defined ARCH_WIN
// wchar_t on Windows should be 2 bytes
static_assert(sizeof(wchar_t) == 2);
 
// Windows C standard functions are ASCII-8 instead of UTF-8, so redirect these functions to wrappers which convert to UTF-8
#define fopen fopen_u8
 
extern "C" {
FILE* fopen_u8(const char* filename, const char* mode);
}
 
namespace std {
    using ::fopen_u8;
}
#endif
 

namespace rack {
 

template <typename To, typename From>
To bitCast(From from) {
    static_assert(sizeof(From) == sizeof(To), "Types must be the same size");
    To to;
    // This is optimized out
    std::memcpy(&to, &from, sizeof(From));
    return to;
}
To bitCast(From from) {…}
 

template <typename T>
T* construct() {
    return new T;
}
T* construct() {…}
 
template <typename T, typename F, typename V, typename... Args>
T* construct(F f, V v, Args... args) {
    T* o = construct<T>(args...);
    o->*f = v;
    return o;
}
T* construct(F f, V v, Args... args) {…}
 

template <typename F>
struct DeferWrapper {
    F f;
    DeferWrapper(F f) : f(f) {}
    ~DeferWrapper() {
        f();
    }
    ~DeferWrapper() {…}
};
struct DeferWrapper {…};
 
template <typename F>
DeferWrapper<F> deferWrapper(F f) {
    return DeferWrapper<F>(f);
}
DeferWrapper<F> deferWrapper(F f) {…}
 
#define DEFER(code) auto CONCAT(_defer_, __COUNTER__) = rack::deferWrapper([&]() code)
 

struct Exception : std::exception {
    std::string msg;
 
    // Attribute index 1 refers to `Exception*` argument so use 2.
    __attribute__((format(printf, 2, 3)))
    Exception(const char* format, ...);
    Exception(const std::string& msg) : msg(msg) {}
    const char* what() const noexcept override {
        return msg.c_str();
    }
    const char* what() const noexcept override  {…}
};
struct Exception : std::exception {…};
 

template <typename C>
const typename C::mapped_type& get(const C& c, const typename C::key_type& key, const typename C::mapped_type& def = typename C::mapped_type()) {
    typename C::const_iterator it = c.find(key);
    if (it == c.end())
        return def;
    return it->second;
}
const typename C::mapped_type& get(const C& c, const typename C::key_type& key, const typename C::mapped_type& def = typename C::mapped_type()) {…}
 

template <typename C>
const typename C::value_type& get(const C& c, typename C::size_type i, const typename C::value_type& def = typename C::value_type()) {
    if (i >= c.size())
        return def;
    return c[i];
}
const typename C::value_type& get(const C& c, typename C::size_type i, const typename C::value_type& def = typename C::value_type()) {…}
 
 
// config
 
extern const std::string APP_NAME;
extern const std::string APP_EDITION;
extern const std::string APP_EDITION_NAME;
extern const std::string APP_VERSION_MAJOR;
extern const std::string APP_VERSION;
extern const std::string APP_OS;
extern const std::string APP_OS_NAME;
extern const std::string APP_CPU;
extern const std::string APP_CPU_NAME;
extern const std::string API_URL;
 
 
} // namespace rack
 
 
// Logger depends on common.hpp, but it is handy to include it along with common.hpp.
#include <logger.hpp>