Utils.hpp

// <Utils> -*- C++ -*-
 
#pragma once
 
#include <string>
#include <math.h>
#include <cxxabi.h>
#include <vector>
#include <algorithm>
 
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
#include <boost/uuid/uuid_io.hpp>
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaExpBackoff.hpp"
 
#define NULL_TO_EMPTY_STR(s) (((s)==nullptr)?"":s)
 
#define DEMANGLE_BUF_LENGTH 4096
 
 
// Custom Literals
 
constexpr inline uint64_t operator ""_u64(unsigned long long i) {
    return i;
}
 
constexpr inline uint32_t operator ""_u32(unsigned long long i) {
    return i;
}
 
constexpr inline uint16_t operator ""_u16(unsigned long long i) {
    return i;
}
 
constexpr inline uint8_t operator ""_u8(unsigned long long i) {
    return i;
}
 
constexpr inline int64_t operator ""_64(unsigned long long i) {
    return i;
}
 
constexpr inline int32_t operator ""_32(unsigned long long i) {
    return i;
}
 
constexpr inline int16_t operator ""_16(unsigned long long i) {
    return i;
}
 
constexpr inline int8_t operator ""_8(unsigned long long i) {
    return i;
}
 
namespace sparta
{
 
inline std::string generateUUID()
{
    boost::uuids::uuid uuid = boost::uuids::random_generator()();
    std::string uuid_str = boost::uuids::to_string(uuid);
    return uuid_str;
}
 
template<typename K, typename V, typename... Args, template<typename...> class MapType>
MapType<V, K> flipMap(const MapType<K, V, Args...>& map){
    auto inverted_map {MapType<V, K>{}};
    for(const auto& [key, value] : map){
        inverted_map.insert({value, key});
    }
    return inverted_map;
}
 
template <typename T,
          typename ConstT=typename std::add_pointer<
              typename std::add_const<
                  typename std::remove_pointer<T>::type
                  >::type
                  >::type>
struct ptr_to_const_obj_ptr {
    typedef ConstT type;
};
 
inline bool isPowerOf2(uint64_t x) {
    return ((x==0) || !(x & (x-1)));
}
 
template <typename T>
inline T computeMask(T size, T& lsb_pos) {
    T mask;
    if(size >= 1){
        double tmp = log2(size);
        if(tmp != floor(tmp)){
            throw SpartaException("For computeMask, size must be a power of 2, is ")
                << size;
        }
        lsb_pos = (T)tmp;
        mask = ~((1 << lsb_pos) - 1);
 
        sparta_assert((1ul << lsb_pos) == size);
    }else{
        lsb_pos = sizeof(T) * 8;
        mask = (T)0;
    }
    return mask;
}
 
template <typename T>
inline T computeMaskShift(T size) {
    T shift;
    computeMask(size, shift);
    return shift;
}
 
 
inline std::string demangle(const std::string& name) noexcept {
    char buf[DEMANGLE_BUF_LENGTH];
    size_t buf_size = DEMANGLE_BUF_LENGTH;
    int status;
    char* out = __cxxabiv1::__cxa_demangle(name.c_str(), buf, &buf_size, &status);
    if(nullptr == out){
        return name;
    }
    return std::string(out);
}
 
template <typename T>
inline T* notNull(T* p) {
    if(p == nullptr){
        throw SpartaException("notNull: pointer was null: " + demangle(typeid(T).name()));
    }
    return p;
}
 
template <typename T> struct is_vector {
    static const bool value = false;
};
 
template <typename T> struct is_vector<std::vector<T> > {
    static const bool value = true;
};
 
inline uint32_t replaceSubstring(std::string& s, const std::string& from, const std::string& to){
    uint32_t num_replacements = 0;
    size_t pos = 0;
    while((pos = s.find(from, pos)) != std::string::npos) {
        s.replace(pos, from.size(), to);
        pos += to.length();
        ++num_replacements;
    }
    return num_replacements;
}
 
inline std::string copyWithReplace(const std::string& s, char from, const std::string& to){
    std::string result;
    result.reserve(s.size()*2); // Take an initial guess so we don't have to reallocate
 
    const char* p = s.c_str();
    while(1){
        if(*p == from){
            result += to;
        }else if(*p == '\0'){
            break;
        }else{
            result += *p;
        }
        ++p;
    }
 
    return result;
}
 
inline std::string convertCPPStringToPython(const std::string& s)
{
    std::string result = s;
    const char * cpp_stuff = "<>:";
    const char replacement = '_';
 
    std::string::size_type pos;
    while(pos = result.find_first_of(cpp_stuff), pos != std::string::npos) {
        result[pos] = replacement;
    }
 
    // Strip parens
    while(pos = result.find_first_of("()"), pos != std::string::npos) {
        std::string newstr = result.substr(0, pos);
        newstr += result.substr(pos + 1);
        result = newstr;
    }
 
 
    return result;
}
 
inline void writeNChars(std::ostream& out, uint32_t num, char chr=' ') {
    for(uint32_t i=0; i<num; ++i){
        out << chr;
    }
}
 
inline std::string toLower(const std::string& s){
    std::string out(s.size(), ' ');
    std::transform(s.begin(), s.end(), out.begin(), (int(*)(int))std::tolower);
    return out;
}
 
template <bool Default>
class OneWayBool
{
    bool value_ = Default; 
 
public:
 
    OneWayBool() = default;
 
    /*
     * \brief Initialize with a value. This value must be the opposite of value
     */
    OneWayBool(bool value)
      : value_(value)
    {
        sparta_assert(value != Default,
                    "OneWayBool<" << Default << "> can only be explicitly initalized to " << !Default
                    << ". Otherwise, it must be default-constructed which will provide a value of "
                    << Default);
    }
 
    operator bool () const { return value_; }
 
    bool operator==(bool b) const { return value_ == b; }
 
    template <bool ArgDefault>
    bool operator==(const OneWayBool<ArgDefault>& b) const { return value_ == b.value_; }
 
    template <bool ArgDefault>
    bool operator=(const OneWayBool<ArgDefault>& b) {
        sparta_assert(Default != b.value_,
                    "OneWayBool<" << Default << "> can never be set to " << Default
                    << " except at initialization");
        value_ = b.value;
        return value_;
    }
 
    bool operator=(bool b) {
        sparta_assert(Default != b,
                    "OneWayBool<" << Default << "> can never be set to " << Default
                    << " except at initialization");
        value_ = b;
        return value_;
    }
 
    void set_DEPRECATED(bool b) {
        value_ = b;
    }
};
 
template <typename T>
class AssignOnceObject
{
    OneWayBool<false> set_; 
 
    bool defaulted_ = false; 
 
    T value_; 
 
    const char * name_ = nullptr; 
 
public:
 
    AssignOnceObject(const AssignOnceObject& rhp)
      : set_(rhp.set_),
        defaulted_(rhp.defaulted_),
        value_(rhp.value_),
        name_(rhp.name_)
    {;}
 
    AssignOnceObject(AssignOnceObject&& rhp)
      : set_(rhp.set_),
        defaulted_(rhp.defaulted_),
        value_(rhp.value_),
        name_(rhp.name_)
    {
        // No need to invalidate rhp
    }
 
    AssignOnceObject(const T& def_value,
                     const char* name)
       : defaulted_(true),
         value_(def_value),
         name_(name)
    {;}
 
    AssignOnceObject()
    {;}
 
    operator const T& () const {
        return get();
    }
 
    const T& get() const {
        sparta_assert(set_ || defaulted_, getPrintableQuotedName_() << " must be set before reading");
        return value_;
    }
 
    bool operator==(const AssignOnceObject<T>& b) const {
        sparta_assert(set_ || defaulted_, getPrintableQuotedName_() << " must be set before comparing");
        return value_ == b.get();
    }
 
    const T& operator=(const AssignOnceObject<T>& b) {
        sparta_assert(set_ == false,
                    getPrintableQuotedName_() << " has already been assigned once. It cannot be re-assigned");
        sparta_assert(b.set_ || b.defaulted_,
                    getPrintableQuotedName_() << " cannot be assigned with another AssignOnceObject which is not defaulted or set");
 
        set_ = true; // arg 'b' must be defaulted or set
        value_ = b.value_;
        return value_;
    }
 
    const T& operator=(const T& v) {
        sparta_assert(set_ == false,
                    getPrintableQuotedName_() << " has already been assigned once. It cannot be re-assigned");
 
        set_ = true;
        value_ = v;
        return value_;
    }
 
    /*
     * \brief Has this value been assigned
     */
    bool assigned() const {
        return set_;
    }
 
private:
 
    template <typename X>
    friend inline std::ostream& operator<<(std::ostream& o, const AssignOnceObject<X>& v);
 
    std::string getPrintableQuotedName_() const {
        if(name_ != nullptr){
            return std::string("\"") + name_ + "\"";
        }else{
            return std::string("\"AssignOnceObject<") + typeid(T).name() + ">";
        }
    }
};
 
template <typename T>
inline std::ostream& operator<<(std::ostream& o, const AssignOnceObject<T>& v) {
    if(v.set_ || v.defaulted_){
        o << v.value_;
    }else{
        o << "<uninitialized>";
    }
    return o;
}
 
template <typename T, T min_bound=std::numeric_limits<T>::min(), T max_bound=std::numeric_limits<T>::max()>
class bounded_int
{
    T val_;
public:
 
    bounded_int(const bounded_int&) = default;
 
    explicit bounded_int(bounded_int&&) = default;
 
    template <typename ArgT=T>
    bounded_int(ArgT, typename std::enable_if<std::is_integral<ArgT>::value==false
                                                  && std::is_convertible<ArgT,T>::value==false>::type* = 0)
     : val_(0)
    {
        static_assert(std::is_integral<ArgT>::value,
                      "Cannot store a non-integral value in a bounded integer type");
    }
 
    template <typename ArgT=T>
    bounded_int(ArgT val, typename std::enable_if<std::is_integral<ArgT>::value==false
                                                  && std::is_convertible<ArgT,T>::value==true>::type* = 0)
     : val_(static_cast<T>(val))
    {
        rangeCheck_(static_cast<T>(val));
    }
 
    // Different sign
    template <typename ArgT=T>
    bounded_int(ArgT val, typename std::enable_if<std::is_integral<ArgT>::value
                                                  && std::is_signed<ArgT>::value!=std::is_signed<T>::value>::type* = 0)
     : val_(val)
    {
        rangeCheck_(val);
    }
 
    // Same sign, smaller (or same-sized) input value data type
    template <typename ArgT=T>
    bounded_int(ArgT val, typename std::enable_if<std::is_integral<ArgT>::value
                                                  && (sizeof(ArgT) <= sizeof(T))
                                                  && std::is_signed<ArgT>::value==std::is_signed<T>::value>::type* = 0)
     : val_(val)
    {
        // Types have same signed-ness and argument is smaller than container.
        // Container type T bounds guaranteed unexceeded
 
        // Check bounds if there are user defined bounds
 
        rangeCheck_(val);
    }
 
    // Same sign, larger input value data type
    template <typename ArgT=T>
    bounded_int(ArgT val, typename std::enable_if<std::is_integral<ArgT>::value
                                                  && (sizeof(ArgT) > sizeof(T))
                                                  && std::is_signed<ArgT>::value==std::is_signed<T>::value>::type* = 0)
     : val_(val)
    {
        // Types have same signed-ness but argument is larger
        rangeCheck_(val);
    }
 
    template <typename ArgT>
    void rangeCheck_(ArgT val){
        lowerRangeCheck_(val);
        upperRangeCheck_(val);
    }
 
    template <typename ArgT=T>
    typename std::enable_if<std::numeric_limits<ArgT>::min()!=min_bound, void>::type
    lowerRangeCheck_(ArgT val) const {
        sparta_assert(val >= min_bound,
            "Tried to store a " << typeid(ArgT).name() << " into a bounded " << typeid(T).name() << ". Not safe to "
            "cast  " << val << " into a type with a minimum of " << min_bound);
    }
 
    template <typename ArgT=T>
    typename std::enable_if<std::numeric_limits<ArgT>::min()==min_bound, void>::type
    lowerRangeCheck_(ArgT val) const {
        (void) val; // Lower bound of val is same as this bounded_int
    }
 
    template <typename ArgT=T>
    typename std::enable_if<std::numeric_limits<ArgT>::max()!=max_bound, void>::type
    upperRangeCheck_(ArgT val) const {
        sparta_assert(val <= max_bound,
            "Tried to store a " << typeid(ArgT).name() << " into a bounded " << typeid(T).name() << ". Not safe to "
            "cast " << val << " into a type with a maximum of " << max_bound);
    }
 
    template <typename ArgT=T>
    typename std::enable_if<std::numeric_limits<ArgT>::max()==max_bound, void>::type
    upperRangeCheck_(ArgT val) const {
        (void) val; // Upper bound of val is same as this bounded_int
    }
 
    //template <T local_min_bound, T local_max_bound, typename U=T>
    //static T bound(U value) {
    //    bt = bounded_type<T, local_min_bound, local_max_bound>(value);
    //    return bt.val_;
    //}
 
    operator T() const { return val_; }
 
    bool operator==(const bounded_int&) = delete;
 
    bool operator=(const bounded_int&) = delete;
 
};
 
} // namespace sparta
 
#define GENERATE_HAS_ATTR(name)                                         \
    template <typename T>                                               \
    struct has_attr_##name {                                            \
        typedef char one[1];                                            \
        typedef char two[2];                                            \
                                                                        \
        template <typename C> static one& test( decltype(&C::name) ) ;  \
        template <typename C> static two& test(...);                    \
                                                                        \
        enum { value = sizeof(test<T>(nullptr)) == sizeof(one) };       \
    };