utils.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_UTILS_HPP__
#define __JOIN_UTILS_HPP__
 
// libjoin.
#include <join/error.hpp>
 
// C++.
#include <stdexcept>
#include <iostream>
#include <iomanip>
#include <chrono>
#include <random>
#include <limits>
#include <chrono>
 
// 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__ 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::high_resolution_clock::now ();
        func (std::forward <Args> (args)...);
        auto end = std::chrono::high_resolution_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 };
    }
}
 
#endif