CppAddons.h

Go to the documentation of this file.

 
/* *************************************************************************/
#ifndef CPPADDONS
#define CPPADDONS
 
#include <type_traits>
#include <cstddef>
#include <climits>
#include <cstdint>
#include <cmath>
#include <cstring>
#include <string>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <chrono>
#include <thread>
#include <bitset>
#include <functional>
#include <mutex>
 
 
/* ****************************************************************************
 
                            MACROS
 
******************************************************************************/
 
/* -----------------------------------------------------------------------------
 
  BINTOSTREAM(v,n)
 
------------------------------------------------------------------------------*/
 
#define BINTOSTREAM(v,n) (std::bitset<n>{v})
 
 
/* -----------------------------------------------------------------------------
 
  DEBUGPREFFIX
 
------------------------------------------------------------------------------*/
 
 
#define JUSTFILENAME (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : \
                      (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : \
                                               __FILE__) )
 
 
#define DEBUGPREFFIX(txt) { \
                       std::ostringstream stringStream; \
                       stringStream << \
                         " [" << JUSTFILENAME << ":" << __FUNCTION__ \
                         << "@" << __LINE__ \
                         << "]";\
                       txt = stringStream.str(); \
                          }
 
/*                   " " << std::chrono::system_clock::now().time_since_epoch() /\
                         std::chrono::microseconds(1) << \
                         " usecs " \*/
 
 
/* -----------------------------------------------------------------------------
 
  RUNTIMEEXCEP(txt), INTERNALERROR(txt)
  
------------------------------------------------------------------------------*/
 
#define RUNTIMEEXCEP(txt) { std::string pdebugpreffix;\
                            DEBUGPREFFIX(pdebugpreffix);\
                            throw(std::runtime_error(pdebugpreffix + ": " + \
                                                     txt)); }
 
#define INTERNALERROR(txt) RUNTIMEEXCEP("Internal error - " + txt)
 
 
/* ****************************************************************************
 
                            TYPES
 
******************************************************************************/
 
/* -----------------------------------------------------------------------------
 
    FIntTraits
 
------------------------------------------------------------------------------*/
 
 
template<typename T>
class FIntTraits
{
};
 
template<>
class FIntTraits<uint8_t>
{
 public:
 
    typedef uint8_t type; 
    static constexpr unsigned char sizeinbits = 8; 
    static constexpr type minval = 0; 
    static constexpr type maxval = UINT8_MAX; 
};
 
template<>
class FIntTraits<uint16_t>
{
 public:
 
    typedef uint16_t type; 
    static constexpr unsigned char sizeinbits = 16; 
    static constexpr type minval = 0; 
    static constexpr type maxval = UINT16_MAX; 
};
 
template<>
class FIntTraits<uint32_t>
{
 public:
 
    typedef uint32_t type; 
    static constexpr unsigned char sizeinbits = 32; 
    static constexpr type minval = 0; 
    static constexpr type maxval = UINT32_MAX; 
};
 
template<>
class FIntTraits<uint64_t>
{
 public:
 
    typedef uint64_t type; 
    static constexpr unsigned char sizeinbits = 64; 
    static constexpr type minval = 0; 
    static constexpr type maxval = UINT64_MAX; 
};
 
template<>
class FIntTraits<int8_t>
{
 public:
 
    typedef int8_t type; 
    static constexpr unsigned char sizeinbits = 8; 
    static constexpr type minval = INT8_MIN; 
    static constexpr type maxval = INT8_MAX; 
};
 
template<>
class FIntTraits<int16_t>
{
 public:
 
    typedef int16_t type; 
    static constexpr unsigned char sizeinbits = 16; 
    static constexpr type minval = INT16_MIN; 
    static constexpr type maxval = INT16_MAX; 
};
 
template<>
class FIntTraits<int32_t>
{
 public:
 
    typedef int32_t type; 
    static constexpr unsigned char sizeinbits = 32; 
    static constexpr type minval = INT32_MIN; 
    static constexpr type maxval = INT32_MAX; 
};
 
template<>
class FIntTraits<int64_t>
{
 public:
 
    typedef int64_t type; 
    static constexpr unsigned char sizeinbits = 64; 
    static constexpr type minval = INT64_MIN; 
    static constexpr type maxval = INT64_MAX; 
};
 
/* -----------------------------------------------------------------------------
 
    NextIntType
 
------------------------------------------------------------------------------*/
 
 
template<uint8_t NUMOFBITS>
class NextIntType // default case: no type fits the requirements, so undefined
{
};
 
template<>
class NextIntType<CHAR_BIT*1>
{
 public:
 
    typedef int16_t type; 
};
 
template<>
class NextIntType<CHAR_BIT*2>
{
 public:
 
    typedef int32_t type; 
};
 
template<>
class NextIntType<CHAR_BIT*3>
{
 public:
 
    typedef int32_t type; 
};
 
template<>
class NextIntType<CHAR_BIT*4>
{
 public:
 
    typedef int64_t type; 
};
 
template<>
class NextIntType<CHAR_BIT*5>
{
 public:
 
    typedef int64_t type; 
};
 
template<>
class NextIntType<CHAR_BIT*6>
{
 public:
 
    typedef int64_t type; 
};
 
template<>
class NextIntType<CHAR_BIT*7>
{
 public:
 
    typedef int64_t type; 
};
 
/* -----------------------------------------------------------------------------
 
    LongestType
 
----------------------------------------------------------------------------- */
 
 
template<typename T0, typename T1, bool sizet0smallerthansizet1>
class LongestType
{
 public:
 
    typedef T0 type; 
};
 
template<typename T0, typename T1>
class LongestType<T0,T1,true>
{
 public:
 
    typedef T1 type; 
};
 
 
/* -----------------------------------------------------------------------------
 
    LongestUnsignedType
 
----------------------------------------------------------------------------- */
 
 
using LongestUnsignedType = unsigned long long;
 
/* -----------------------------------------------------------------------------
 
    NaturalRange
 
------------------------------------------------------------------------------*/
 
 
template <typename BaseIntegerType, // should be unsigned
          BaseIntegerType MAXVAL> // maximum value, inclusive
class NaturalRange
{
 public:
 
    typedef BaseIntegerType basetype; 
 
    NaturalRange(BaseIntegerType v):baseval_{v} { if (v > MAXVAL) outOfRange();}
 
    operator BaseIntegerType(void) const noexcept { return(baseval_); }
 
    BaseIntegerType numeric(void) const noexcept { return(baseval_); }
 
    NaturalRange & operator++(void)
        { if (baseval_ == MAXVAL) outOfRange();
          ++baseval_;
          return(*this); }
 
    NaturalRange & operator++(int)
       { if (baseval_ == MAXVAL) outOfRange();
         ++baseval_;
         return(*this); }
 
    NaturalRange & operator--(void)
      { if (baseval_ == 0) outOfRange();
        --baseval_;
        return(*this); }
 
    NaturalRange & operator--(int)
      { if (baseval_ == 0) outOfRange();
        --baseval_;
        return(*this); }
 
    NaturalRange & operator+=(BaseIntegerType o)
      { baseval_ += o;
        if (baseval_ > MAXVAL) outOfRange();
        return(*this); }
 
    NaturalRange & operator-=(BaseIntegerType o)
      { baseval_ -= o;
        if (baseval_ < 0) outOfRange();
        return(*this); }
 
 protected:
 
    static void outOfRange(void) { RUNTIMEEXCEP("Out of range"); }
 
    BaseIntegerType baseval_; 
 
};
 
 
/* -----------------------------------------------------------------------------
 
    Enum class: IntervalClosedness
    Template class: Interval
 
------------------------------------------------------------------------------*/
 
enum class IntervalCl: uint8_t {
                                CLOSED,
                                OPENED,
                                LEFT_CLOSED,
                                RIGHT_CLOSED
                               };
 
 
 
template <typename ELEMTYPE>
class Interval
{
 public:
 
    Interval(void): closedl_{false},
                    closedr_{false},
                    allclosed_{false},
                    min_{ELEMTYPE{}}, // if numerical, gets 0
                    max_{ELEMTYPE{}} {}
 
    Interval(ELEMTYPE mi, ELEMTYPE ma, 
             IntervalCl cl = IntervalCl::CLOSED): 
                                    closedl_{(cl == IntervalCl::CLOSED) ||
                                             (cl == IntervalCl::LEFT_CLOSED)},
                                    closedr_{(cl == IntervalCl::CLOSED) ||
                                             (cl == IntervalCl::RIGHT_CLOSED)},
                                    allclosed_{cl == IntervalCl::CLOSED},
                                    min_{mi},max_{ma} 
        { if (ma < mi) RUNTIMEEXCEP("Invalid interval (max " +
                                    std::to_string(ma) + " is < min " +
                                    std::to_string(mi) + ")"); 
          if ((closedl_ != closedr_) && (ma == mi)) 
            RUNTIMEEXCEP("Invalid semi-closed interval"); }
 
 
    ELEMTYPE minimum(void) const noexcept { return(min_); }
 
    ELEMTYPE maximum(void) const noexcept { return(max_); }
    
    ELEMTYPE width(void) const noexcept { return(max_ - min_); }
 
    IntervalCl closedness(void) const noexcept 
        { return(closednessFromCloses(closedl_,closedr_)); }
 
    bool closedMin(void) const noexcept { return(closedl_); }
 
    bool closedMax(void) const noexcept { return(closedr_); }
 
    bool empty(void) const noexcept { return((!allclosed_) && (min_ == max_)); }
 
    Interval intersect(const Interval & oth) const noexcept
    {
        if ( ((oth.min_ > max_) || (oth.max_ < min_)) ||
             ((oth.closedl_ != closedr_) && (oth.min_ == max_)) ||
             ((oth.closedr_ != closedl_) && (oth.max_ == min_)) ) 
            return(Interval{});
        ELEMTYPE a,b;
        bool cl,cr;
        if ((oth.min_ > min_) || (oth.min_ == min_)) 
        {
            a = oth.min_;
            cl = oth.closedl_;
            b = std::min(oth.max_,max_);
            cr = closedr_;
        }
        else 
        {
            a = min_;
            cl = closedl_;
            b = std::min(oth.max_,max_);
            cr = oth.closedr_;
        }
        return(Interval{a,b,closednessFromCloses(cl,cr)});
    }
 
    bool containPoint(ELEMTYPE e) const noexcept
        { return( ((e > min_) && (e < max_)) ||
                  ((e == min_) && (closedl_)) ||
                  ((e == max_) && (closedr_)) ); }
 
    std::string to_string(void) const
        { return(std::string(1, closedl_ ? '[' : '(') +
                 std::to_string(min_) + ".." + std::to_string(max_) +
                 std::string(1, closedl_ ? ']' : ')')); }
 
 
 private:
 
    static IntervalCl closednessFromCloses(bool l, bool r) noexcept
        { return(l == r ? 
                    (l ? IntervalCl::CLOSED : IntervalCl::OPENED) :
                    (l ? IntervalCl::LEFT_CLOSED : IntervalCl::RIGHT_CLOSED)); }
 
    const bool closedl_,closedr_,allclosed_;
 
    ELEMTYPE min_,max_;
};
 
 
/* -----------------------------------------------------------------------------
 
    IterableEnum
 
------------------------------------------------------------------------------*/
 
 
template <typename T>
class IterableEnum
{
 public:
 
        /* ------------------------ Types, consts., etc. -------------------- */
 
    class Iterator
    {
     public:
 
        Iterator(T val = T::FIRST) noexcept: v_{static_cast<int>(val)}
            {}
 
        // leave all constructors, move and copies by default
 
        T operator*(void) const noexcept { return(static_cast<T>(v_)); }
 
        Iterator & operator++(void) noexcept
            { if (v_ != static_cast<int>(T::LAST)+1) ++v_; return(*this); }
 
        Iterator operator++(int) noexcept
            { Iterator now = *this; operator++(); return(now); }
 
        bool operator!=(const Iterator &o) const noexcept { return(v_ != o.v_);}
 
        bool operator==(const Iterator &o) const noexcept { return(v_ == o.v_);}
 
     private:
 
        int v_; // cannot be T because it needs sometimes to be LAST+1
    };
 
        /* ------------------------ Class methods ------------------------ */
 
    static IterableEnum & theIterable(void) noexcept
        { static IterableEnum ie; return(ie); }
 
        /* ------------------------ Constructors ------------------------ */
 
    // constructors are private, but move/copies are not
    IterableEnum(const IterableEnum &) = default; 
    IterableEnum(IterableEnum &&) = default; 
    IterableEnum & operator=(const IterableEnum &o) { return(*this); }
    IterableEnum & operator=(IterableEnum &&o) { return(*this); }
 
        /* ------------------------ Methods ------------------------ */
 
    Iterator begin(void) const noexcept { return(Iterator()); }
 
    Iterator end(void) const noexcept
        { return(Iterator(static_cast<T>(static_cast<int>(T::LAST)+1))); }
 
 
 private:
 
    IterableEnum(void) = default; // private for forcing to use the singleton
    virtual ~IterableEnum(void) = default;
};
 
 
/* -----------------------------------------------------------------------------
 
    Template class: ThreadSafer
 
------------------------------------------------------------------------------*/
 
 
template <class Unsafe>
class ThreadSafer
{
 public:
 
    class Proxy
    {
     public:
 
        Proxy(Unsafe * obj, std::mutex & mux):obj_{obj},mux_{mux} {mux_.lock();}
 
        Proxy(Proxy && oth):obj_{oth.obj_},mux_{oth.mux_} {}
 
        ~Proxy(void) { mux_.unlock(); }
 
        Proxy(const Proxy &) = delete;
        Proxy & operator=(const Proxy &) = delete;
        Proxy & operator=(Proxy &&) = delete;
        
        Unsafe * operator->(void) { return(obj_); }
 
     private:
 
        Unsafe * obj_;
        std::mutex & mux_;
    };
 
 
    ThreadSafer(Unsafe & obj):obj_{&obj} {}
 
    ThreadSafer(const ThreadSafer &) = delete;
    ThreadSafer(ThreadSafer &&) = delete;
    ThreadSafer & operator=(const ThreadSafer &) = delete;
    ThreadSafer & operator=(ThreadSafer &&) = delete;
 
    ~ThreadSafer(void) = default;
 
    Proxy safe(void) 
        { return(Proxy{obj_,mux_}); }
 
 private:
 
    Unsafe * obj_;
    std::mutex mux_; 
};
 
 
 
/* ****************************************************************************
 
                            CONSTS
 
******************************************************************************/
 
/* -----------------------------------------------------------------------------
 
    PI: the famous constant, not defined yet in C++11  ¬¬
 
------------------------------------------------------------------------------*/
 
 
static const double PI =  std::acos(-1.0);
 
 
/* ****************************************************************************
 
                            FUNCTIONS
 
******************************************************************************/
 
/* -----------------------------------------------------------------------------
 
    string_hex_to_num()
 
------------------------------------------------------------------------------*/
 
 
template <typename NumType>
NumType string_hex_to_num(const std::string & txt)
{
    static_assert(std::is_unsigned<NumType>::value,
                  "from_string_hex only works with integral unsigned types");
 
    NumType v{0};
    NumType mult{0};
    NumType c;
    for (int f = static_cast<int>(txt.size() - 1); f >= 0; --f)
    {
        if (std::isdigit(txt[f])) c = txt[f] - '0';
        else if (std::isalpha(txt[f]))
        {
            if (std::isupper(txt[f])) c = txt[f] - 'A' + 10;
            else c = txt[f] - 'a' + 10;
            if (c > 15) break;
        }
        else break;
        v += c << mult;
        mult += 4;
    }
    return(v);
}
 
/* -----------------------------------------------------------------------------
 
    num_to_string_hex()
 
------------------------------------------------------------------------------*/
 
 
template <typename NumType>
std::string num_to_string_hex(NumType n, bool padding = true)
{
    static_assert(std::is_integral<NumType>::value,
                  "to_string_hex only works with integral types");
 
    std::stringstream stream;
    if (padding)
        stream << std::hex << 
                  std::setw(sizeof(NumType)*2) << std::setfill('0') <<
                  std::uppercase <<
                  static_cast<LongestUnsignedType>(n); // cast needed for uint8_t...
    else stream << std::hex << static_cast<LongestUnsignedType>(n);// not being char
    return(stream.str());
}
 
/* -----------------------------------------------------------------------------
 
    hex_dump()
 
------------------------------------------------------------------------------*/
 
 
template <typename PointedType>
std::string hex_dump(const PointedType * data, size_t howmany, bool toupp = true,
                     bool sepelems = true)
{
    std::string res;
    if ((data != nullptr) && (howmany > 0))
    {
        const auto * bytes = reinterpret_cast<const uint8_t *>(data);
        for (size_t f = 0; f < howmany; ++f)
        {
            res += num_to_string_hex(*bytes);
            if (sepelems && (f < howmany - 1)) res.push_back(' ');
            ++bytes;
        }
        if (toupp)
            std::transform(res.begin(),res.end(),res.begin(),
                           [](char c)->char 
                           { return(std::toupper(c)); });
    }
    return(res);
}
 
/* -----------------------------------------------------------------------------
 
    pointer_to_number(p)
 
------------------------------------------------------------------------------*/
 
inline LongestUnsignedType pointer_to_number(const void * p) noexcept
    { return(reinterpret_cast<LongestUnsignedType>(p)); }
 
 
/* -----------------------------------------------------------------------------
 
    all_bits_set_up_to_n(n)
 
------------------------------------------------------------------------------*/
 
constexpr uint8_t all_bits_set_up_to_n(uint8_t n)
{ // a constexpr can also be used with non-constexpr args, although in that
  // case a normal inline function will be generated (instead of calculating
  // the result in compiling time)
 
    return( static_cast<uint8_t>( (static_cast<uint16_t>(1) << (n+1)) - 1) );
}
 
/* -----------------------------------------------------------------------------
 
    reverse_bits(b)
 
------------------------------------------------------------------------------*/
 
template <typename T, unsigned char N = sizeof(T)*CHAR_BIT>
T reverse_bits(T v)
{
    T res = 0;
    for (unsigned char f=0; f<N; f++)
    {
        res <<= 1;
        if (v & 1) res |= 1;
        v >>= 1;
    }
    return(res);
}
 
/* -----------------------------------------------------------------------------
 
    count_bits_set(b)
 
------------------------------------------------------------------------------*/
 
template <typename T>
unsigned char count_bits_set(T v)
{
    unsigned char n=0;
    for (unsigned char f=0; f<sizeof(T)*CHAR_BIT; f++)
    {
        n += static_cast<unsigned char>((v & 1)!=0);
        v >>= 1;
    }
    return(n);
}
 
/* -----------------------------------------------------------------------------
 
    most_significant_bit_set(b)
 
------------------------------------------------------------------------------*/
 
template <typename T, unsigned char N = sizeof(T)*CHAR_BIT>
unsigned char most_significant_bit_set(T b)
{
    T mask = static_cast<T>(1) << (N-1);
    unsigned char res = N - 1;
    for (unsigned char f = 0; f < N; ++f)
    {
        if ((b & mask) != 0) return(res);
        --res;
        mask >>= 1;
    }
    return(N);
}
 
/* -----------------------------------------------------------------------------
 
    least_significant_bit_set(b)
 
------------------------------------------------------------------------------*/
 
template <typename T, unsigned char N = sizeof(T)*CHAR_BIT>
unsigned char least_significant_bit_set(T b)
{
    T mask = static_cast<T>(1);
    unsigned char res = 0;
    for (unsigned char f = 0; f < N; ++f)
    {
        if ((b & mask) != 0) return(res);
        ++res;
        mask <<= 1;
    }
    return(N);
}
 
/* -----------------------------------------------------------------------------
 
    more_bits_set(b1,b2)
 
------------------------------------------------------------------------------*/
 
template <typename T>
bool more_bits_set(T b1, T b2)
{
    if ((b1 & b2) != b2) return(false); // if some bit in B2 is unset in B1
    // here all bits of B2 are set in B1; thus, B1 & ~B2 yields new bits in B1
    return( (b1 & (~b2)) != 0); // at least 1 bit in B1 is set but unset in B2
}
 
/* -----------------------------------------------------------------------------
 
    substract_bits(b1,b2)
 
------------------------------------------------------------------------------*/
 
 
template <typename T>
T substract_bits(T b1, T b2)
{
    return( b1 & (~b2) );
}
 
/* -----------------------------------------------------------------------------
 
    new_bits_set(b1,b2)
 
------------------------------------------------------------------------------*/
 
template <typename T>
bool new_bits_set(T b1, T b2)
{
    return( substract_bits(b1,b2) != 0 );
}
 
/* -----------------------------------------------------------------------------
 
    bits_of_constexprvalue(v)
    
------------------------------------------------------------------------------*/
 
template <unsigned char N>
constexpr unsigned char bits_of_constexprvalue() 
    { return(N == 0 ? 0 : (1 + bits_of_constexprvalue<(N >> 1)>())); }
 
 
/* -----------------------------------------------------------------------------
 
    bits_of_value(v)
    
------------------------------------------------------------------------------*/
 
template <typename T>
unsigned char bits_of_value(T v)
    { auto nbs = most_significant_bit_set<T>(v);
      return(nbs == sizeof(T)*CHAR_BIT ? 0 : nbs); }
 
 
/* -----------------------------------------------------------------------------
 
    for_within()
 
------------------------------------------------------------------------------*/
 
 
template<class TIter, class TBody>
void for_within(TIter i_first, TIter i_last, const TBody & body)
{
    if (i_first>i_last) return;
    TIter i=i_first;
    do
    {
        body(i);
        if (i==i_last) return; // in a for-loop this & the next would be swapped
        i++;
    } while(1);
}
 
/* -----------------------------------------------------------------------------
 
    Functions to move and copy memory blocks correctly in machines that
    have CHAR_BIT > 8.
 
------------------------------------------------------------------------------*/
 
#if CHAR_BIT==8
    #define fill_byte(dest,value,count) std::memset(dest,value,count)
    #define move_bytes(dest,src,count) std::memmove(dest,src,count)
#else
    #error Cannot compile in machines where char != 8 bits.
#endif
 
/* -----------------------------------------------------------------------------
 
    pad_string
 
------------------------------------------------------------------------------*/
 
 
inline void pad_string(std::string & s, size_t len, bool leftorright = true, 
                                         char padding = '\t')
{
    const size_t ss = s.size();
    if (ss < len) 
    {
        const size_t howmany = len - ss;
        if (leftorright) s.insert(0,howmany,padding);
        else s.insert(ss,howmany,padding);
    }
}
 
/* -----------------------------------------------------------------------------
 
    time_text
 
------------------------------------------------------------------------------*/
 
inline LongestUnsignedType utime_now(void)
{ return(std::chrono::duration_cast<std::chrono::microseconds>(
                    std::chrono::steady_clock::now().time_since_epoch()
                                                                     ).count()); }
 
#endif
 // CppAddOns