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 <type_traits>
#include <stdexcept>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <utility>
#include <chrono>
#include <random>
#include <limits>
#include <bit>
 
// C.
#include <cstdint>
#include <cstddef>
#include <cstring>
 
#define JOIN_ALWAYS_INLINE inline __attribute__ ((always_inline))
 
#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
    {
        struct lessNoCase
        {
            bool operator() (const std::string& a, const std::string& b) const noexcept
            {
                return ::strcasecmp (a.c_str (), b.c_str ()) < 0;
            }
        };
    }
 
    template <typename Exception, typename... Args>
    [[noreturn]] __attribute__ ((cold, noinline)) void throwException (Args&&... args)
    {
        throw Exception (std::forward<Args> (args)...);
    }
 
    template <class Type>
    inline Type& swap (Type& val)
        requires (std::is_arithmetic_v<Type> && sizeof (Type) <= sizeof (uint64_t))
    {
        if constexpr (std::endian::native == std::endian::little)
        {
            if constexpr (sizeof (Type) == sizeof (uint16_t))
            {
                val = std::bit_cast<Type> (__builtin_bswap16 (std::bit_cast<uint16_t> (val)));
            }
            else if constexpr (sizeof (Type) == sizeof (uint32_t))
            {
                val = std::bit_cast<Type> (__builtin_bswap32 (std::bit_cast<uint32_t> (val)));
            }
            else if constexpr (sizeof (Type) == sizeof (uint64_t))
            {
                val = std::bit_cast<Type> (__builtin_bswap64 (std::bit_cast<uint64_t> (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 bool readBytes (const char*& cur, const char* end, void* out, size_t size) noexcept
    {
        if (size > static_cast<size_t> (end - cur))
        {
            join::lastError = make_error_code (Errc::MessageTooLong);
            return false;
        }
 
        ::memcpy (out, cur, size);
        cur += size;
 
        return true;
    }
 
    inline bool writeBytes (char*& cur, const char* end, const void* in, size_t size) noexcept
    {
        if (size > static_cast<size_t> (end - cur))
        {
            join::lastError = make_error_code (Errc::MessageTooLong);
            return false;
        }
 
        ::memcpy (cur, in, size);
        cur += size;
 
        return true;
    }
 
    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 constexpr (std::endian::native == std::endian::little)
            {
                sum += *reinterpret_cast<const uint8_t*> (data);
            }
            else
            {
                sum += *reinterpret_cast<const uint8_t*> (data) << 8;
            }
        }
 
        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);
        std::ostringstream oss;
 
        for (int i = 0; i < int (size); i += 16)
        {
            oss << std::hex << std::uppercase << std::setw (8);
            oss << std::setfill ('0') << i << std::dec << ":";
 
            for (int j = 0; j < 16; ++j)
            {
                if (j % 4 == 0)
                    oss << std::dec << " ";
 
                if (i + j < int (size))
                {
                    oss << std::hex << std::uppercase << std::setw (2);
                    oss << std::setfill ('0') << static_cast<int> (buf[i + j]);
                }
                else
                    oss << std::dec << "  ";
            }
 
            oss << std::dec << " ";
 
            for (int j = 0; j < 16; ++j)
            {
                if (i + j < int (size))
                {
                    if (isprint (buf[i + j]))
                        oss << buf[i + j];
                    else
                        oss << ".";
                }
            }
 
            oss << "\n";
        }
 
        oss << "\n";
 
        out << oss.str () << std::flush;
    }
 
    template <typename Type>
    Type randomize ()
    {
        static_assert (std::is_integral_v<Type>, "randomize requires an integral type");
        thread_local 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