utils.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_UTILS_HPP
#define JOIN_CORE_UTILS_HPP
 
// libjoin.
#include <join/error.hpp>
 
// C++.
#include <stdexcept>
#include <iostream>
#include <iomanip>
#include <chrono>
#include <random>
#include <limits>
 
// C.
#include <endian.h>
#include <cstdint>
#include <cstddef>
#include <cstring>
 
#define JOIN_LIKELY(x) __builtin_expect (!!(x), 1)
#define JOIN_UNLIKELY(x) __builtin_expect (!!(x), 0)
 
#define OUT_ENUM(a) \
    case a:         \
        return #a
 
namespace join
{
    namespace details
    {
        template <typename Type, size_t sz>
        struct _byteswap
        {
            inline Type operator() ([[maybe_unused]] Type val)
            {
                throw std::out_of_range ("data size");
            }
        };
 
        template <typename Type>
        struct _byteswap<Type, 1>
        {
            inline Type operator() (Type val)
            {
                return val;
            }
        };
 
        template <typename Type>
        struct _byteswap<Type, 2>
        {
            inline Type operator() (Type val)
            {
                if (BYTE_ORDER == LITTLE_ENDIAN)
                {
                    return (val >> 8) | (val << 8);
                }
                return val;
            }
        };
 
        template <typename Type>
        struct _byteswap<Type, 4>
        {
            inline Type operator() (Type val)
            {
                if (BYTE_ORDER == LITTLE_ENDIAN)
                {
                    return ((val & 0xff000000) >> 24) | ((val & 0x00ff0000) >> 8) | ((val & 0x0000ff00) << 8) |
                           ((val & 0x000000ff) << 24);
                }
                return val;
            }
        };
 
        template <typename Type>
        struct _byteswap<Type, 8>
        {
            inline Type operator() (Type val)
            {
                if (BYTE_ORDER == LITTLE_ENDIAN)
                {
                    return ((val & 0xff00000000000000ull) >> 56) | ((val & 0x00ff000000000000ull) >> 40) |
                           ((val & 0x0000ff0000000000ull) >> 24) | ((val & 0x000000ff00000000ull) >> 8) |
                           ((val & 0x00000000ff000000ull) << 8) | ((val & 0x0000000000ff0000ull) << 24) |
                           ((val & 0x000000000000ff00ull) << 40) | ((val & 0x00000000000000ffull) << 56);
                }
                return val;
            }
        };
 
        template <>
        struct _byteswap<float, 4>
        {
            inline float operator() (float val)
            {
                if (BYTE_ORDER == LITTLE_ENDIAN)
                {
                    union
                    {
                        float f;
                        uint32_t i;
                    } tmp;
 
                    tmp.f = val;
                    tmp.i = _byteswap<uint32_t, sizeof (uint32_t)> () (tmp.i);
                    return tmp.f;
                }
                return val;
            }
        };
 
        template <>
        struct _byteswap<double, 8>
        {
            inline double operator() (double val)
            {
                if (BYTE_ORDER == LITTLE_ENDIAN)
                {
                    union
                    {
                        double f;
                        uint64_t i;
                    } tmp;
 
                    tmp.f = val;
                    tmp.i = _byteswap<uint64_t, sizeof (uint64_t)> () (tmp.i);
                    return tmp.f;
                }
                return val;
            }
        };
 
        template <class Type>
        struct _swap
        {
            inline Type operator() (Type val)
            {
                return _byteswap<Type, sizeof (Type)> () (val);
            }
        };
 
        struct lessNoCase
        {
            bool operator() (const std::string& a, const std::string& b) const noexcept
            {
                return ::strcasecmp (a.c_str (), b.c_str ()) < 0;
            }
        };
    }
 
    template <class Type>
    inline Type& swap (Type& val)
    {
        val = details::_swap<Type> () (val);
        return val;
    }
 
    inline bool compareNoCase (const std::string& a, const std::string& b)
    {
        return ((a.size () == b.size ()) && std::equal (a.begin (), a.end (), b.begin (), [] (char c1, char c2) {
                    return std::toupper (c1) == std::toupper (c2);
                }));
    }
 
    inline std::string& trimLeft (std::string& s)
    {
        return s.erase (0, s.find_first_not_of ("\f\t\v\r\n "));
    }
 
    inline std::string& trimRight (std::string& s)
    {
        return s.erase (s.find_last_not_of (" \f\t\v\r\n") + 1);
    }
 
    inline std::string& trim (std::string& s)
    {
        return trimLeft (trimRight (s));
    }
 
    inline std::string& replaceAll (std::string& str, const std::string& toReplace, const std::string& by)
    {
        size_t pos = 0;
 
        while ((pos = str.find (toReplace, pos)) != std::string::npos)
        {
            str.replace (pos, toReplace.length (), by);
            pos += by.length ();
        }
 
        return str;
    }
 
    inline std::vector<std::string> split (const std::string& in, const std::string& delim)
    {
        std::vector<std::string> tokens;
        if (in.size ())
        {
            size_t beg = 0, end = in.find (delim);
            size_t sz = delim.size ();
            while (end != std::string::npos)
            {
                tokens.push_back (in.substr (beg, end - beg));
                beg = end + sz;
                end = in.find (delim, beg);
            }
            tokens.push_back (in.substr (beg));
        }
        return tokens;
    }
 
    inline std::vector<std::string> rsplit (const std::string& in, const std::string& delim)
    {
        std::vector<std::string> tokens;
        if (in.size ())
        {
            size_t beg = in.rfind (delim), end = std::string::npos;
            size_t sz = delim.size ();
            while (beg != std::string::npos)
            {
                tokens.push_back (in.substr (beg + sz, end - beg - sz));
                end = beg;
                beg = in.rfind (delim, end - sz);
            }
            tokens.push_back (in.substr (0, end));
        }
        return tokens;
    }
 
    inline bool getline (std::istream& in, std::string& line, std::streamsize max = 1024)
    {
        line.clear ();
 
        while (max--)
        {
            char ch = in.get ();
            if (in.fail ())
            {
                return false;
            }
 
            if (ch == '\r')
            {
                continue;
            }
 
            if (ch == '\n')
            {
                return true;
            }
 
            line.push_back (ch);
        }
 
        join::lastError = make_error_code (Errc::MessageTooLong);
 
        return false;
    }
 
    inline bool getline (std::streambuf& in, std::string& line, std::streamsize max = 1024)
    {
        std::istream istream (&in);
        return getline (istream, line, max);
    }
 
    inline uint16_t checksum (const uint16_t* data, size_t len, uint16_t current = 0) noexcept
    {
        uint32_t sum = current;
 
        while (len > 1)
        {
            sum += *data++;
            len -= 2;
        }
 
        if (len == 1)
        {
#if __BYTE_ORDER == __LITTLE_ENDIAN
            sum += *reinterpret_cast<const uint8_t*> (data);
#else
            sum += *reinterpret_cast<const uint8_t*> (data) << 8;
#endif
        }
 
        sum = (sum >> 16) + (sum & 0xffff);
        sum += (sum >> 16);
 
        return static_cast<uint16_t> (~sum);
    }
 
    inline void dump (const void* data, unsigned long size, std::ostream& out = std::cout)
    {
        const uint8_t* buf = reinterpret_cast<const uint8_t*> (data);
 
        for (int i = 0; i < int (size); i += 16)
        {
            out << std::hex << std::uppercase << std::setw (8);
            out << std::setfill ('0') << i << std::dec << ":";
 
            for (int j = 0; j < 16; ++j)
            {
                if (j % 4 == 0)
                    out << std::dec << " ";
 
                if (i + j < int (size))
                {
                    out << std::hex << std::uppercase << std::setw (2);
                    out << std::setfill ('0') << static_cast<int> (buf[i + j]);
                }
                else
                    out << std::dec << "  ";
            }
 
            out << std::dec << " ";
 
            for (int j = 0; j < 16; ++j)
            {
                if (i + j < int (size))
                {
                    if (isprint (buf[i + j]))
                        out << buf[i + j];
                    else
                        out << ".";
                }
            }
 
            out << std::endl;
        }
 
        out << std::endl;
    }
 
    template <typename Type>
    std::enable_if_t<std::numeric_limits<Type>::is_integer, Type> randomize ()
    {
        std::random_device rnd;
        std::uniform_int_distribution<Type> dist{};
        return dist (rnd);
    }
 
    template <class Func, class... Args>
    std::chrono::milliseconds benchmark (Func&& func, Args&&... args)
    {
        auto beg = std::chrono::steady_clock::now ();
        func (std::forward<Args> (args)...);
        auto end = std::chrono::steady_clock::now ();
        return std::chrono::duration_cast<std::chrono::milliseconds> (end - beg);
    }
 
    template <typename Clock, typename Duration>
    struct timespec toTimespec (std::chrono::time_point<Clock, Duration> timePoint)
    {
        auto secs = std::chrono::time_point_cast<std::chrono::seconds> (timePoint);
        auto ns = std::chrono::time_point_cast<std::chrono::nanoseconds> (timePoint) -
                  std::chrono::time_point_cast<std::chrono::nanoseconds> (secs);
 
        auto scount = secs.time_since_epoch ().count ();
        auto ncount = ns.count ();
 
        return {.tv_sec = scount, .tv_nsec = ncount};
    }
 
    template <typename Rep, typename Period>
    struct timespec toTimespec (std::chrono::duration<Rep, Period> duration)
    {
        auto secs = std::chrono::duration_cast<std::chrono::seconds> (duration);
        auto ns = std::chrono::duration_cast<std::chrono::nanoseconds> (duration - secs);
 
        auto scount = secs.count ();
        auto ncount = ns.count ();
 
        return {.tv_sec = scount, .tv_nsec = ncount};
    }
 
    constexpr bool isPow2 (uint64_t value) noexcept
    {
        return (value != 0) && ((value & (value - 1)) == 0);
    }
 
    constexpr uint64_t nextPow2 (uint64_t value) noexcept
    {
        if (value == 0)
        {
            return 1;
        }
 
        value--;
        value |= value >> 1;
        value |= value >> 2;
        value |= value >> 4;
        value |= value >> 8;
        value |= value >> 16;
        value |= value >> 32;
 
        return value + 1;
    }
}
 
#endif