uint128_t.h

/* Copyright (c) 2010-2017, Cedric Stalder <cedric.stalder@gmail.com>
 *                          Stefan Eilemann <eile@eyescale.ch>
 *                          Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This file is part of Servus <https://github.com/HBPVIS/Servus>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef SERVUS_UINT128_H
#define SERVUS_UINT128_H

#include <servus/api.h>
#include <servus/types.h>

#include <sstream>
#ifdef _MSC_VER
// Don't include <servus/types.h> to be minimally intrusive for apps
// using uint128_t
#include <basetsd.h>
typedef UINT64 uint64_t;
#define snprintf _snprintf
#else
#include <stdint.h>
#endif

namespace servus
{
class uint128_t;
std::ostream& operator<<(std::ostream& os, const uint128_t& id);

class uint128_t
{
public:
    explicit uint128_t(const unsigned long long low_ = 0)
        : _high(0)
        , _low(low_)
    {
    }

    explicit uint128_t(const unsigned long low_)
        : _high(0)
        , _low(low_)
    {
    }

    explicit uint128_t(const int low_)
        : _high(0)
        , _low(low_)
    {
    }

    uint128_t(const uint64_t high_, const uint64_t low_)
        : _high(high_)
        , _low(low_)
    {
    }

    explicit uint128_t(const std::string& string)
        : _high(0)
        , _low(0)
    {
        *this = string;
    }

    bool isUUID() const { return high() != 0; }
    uint128_t& operator=(const servus::uint128_t& rhs)
    {
        _high = rhs._high;
        _low = rhs._low;
        return *this;
    }

    uint128_t& operator=(const uint64_t rhs)
    {
        _high = 0;
        _low = rhs;
        return *this;
    }

    uint128_t& operator=(const int rhs)
    {
        _high = 0;
        _low = rhs;
        return *this;
    }

    SERVUS_API uint128_t& operator=(const std::string& from);

    bool operator==(const servus::uint128_t& rhs) const
    {
        return _high == rhs._high && _low == rhs._low;
    }

    bool operator!=(const servus::uint128_t& rhs) const
    {
        return _high != rhs._high || _low != rhs._low;
    }

    bool operator==(const unsigned long long& low_) const
    {
        return *this == uint128_t(low_);
    }

    bool operator!=(const unsigned long long& low_) const
    {
        return *this != uint128_t(low_);
    }

    bool operator<(const servus::uint128_t& rhs) const
    {
        if (_high < rhs._high)
            return true;
        if (_high > rhs._high)
            return false;
        return _low < rhs._low;
    }

    bool operator>(const servus::uint128_t& rhs) const
    {
        if (_high > rhs._high)
            return true;
        if (_high < rhs._high)
            return false;
        return _low > rhs._low;
    }

    bool operator<=(const servus::uint128_t& rhs) const
    {
        if (_high < rhs._high)
            return true;
        if (_high > rhs._high)
            return false;
        return _low <= rhs._low;
    }

    bool operator>=(const servus::uint128_t& rhs) const
    {
        if (_high > rhs._high)
            return true;
        if (_high < rhs._high)
            return false;
        return _low >= rhs._low;
    }

    uint128_t& operator++()
    {
        ++_low;
        if (!_low)
            ++_high;

        return *this;
    }

    uint128_t& operator--()
    {
        if (!_low)
            --_high;
        --_low;
        return *this;
    }

    uint128_t& operator+=(const servus::uint128_t& rhs)
    {
        const uint64_t oldLow = _low;
        _low += rhs._low;
        if (_low < oldLow) // overflow
            _high += rhs._high + 1;
        else
            _high += rhs._high;
        return *this;
    }

    const uint64_t& low() const { return _low; }
    const uint64_t& high() const { return _high; }
    uint64_t& low() { return _low; }
    uint64_t& high() { return _high; }
    std::string getShortString() const
    {
        std::stringstream stream;
        stream << std::hex << _high << _low;
        const std::string str = stream.str();
        return str.substr(0, 3) + ".." +
               str.substr(str.length() - 3, std::string::npos);
    }

    std::string getString() const
    {
        // OPT: snprintf is faster than using std::stringstream
        char buffer[34] /* 2 x 16 bytes + : + \0 */;
        snprintf(buffer, 34, "%llx:%llx", ull_t(high()), ull_t(low()));
        return std::string(buffer);
    }

    template <class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
        ar& low();
        ar& high();
    }

private:
    uint64_t _high;
    uint64_t _low;
};

inline std::ostream& operator<<(std::ostream& os, const uint128_t& id)
{
    if (id.high() == 0)
        os << std::hex << id.low() << std::dec;
    else
        os << std::hex << id.high() << ':' << id.low() << std::dec;
    return os;
}

inline std::istream& operator>>(std::istream& is, uint128_t& id)
{
    std::string str;
    is >> str;
    id = str;
    return is;
}

inline uint128_t operator+(const servus::uint128_t& a, const uint64_t& b)
{
    uint128_t result = a;
    result.low() += b;
    if (result.low() < a.low())
        ++result.high();
    return result;
}

inline uint128_t operator+(const servus::uint128_t& a,
                           const servus::uint128_t& b)
{
    uint128_t result = a;
    result += b;
    return result;
}

inline uint128_t operator-(const servus::uint128_t& a, const uint64_t& b)
{
    uint128_t result = a;
    result.low() -= b;
    if (result.low() > a.low())
        --result.high();
    return result;
}

inline uint128_t operator&(const servus::uint128_t& a,
                           const servus::uint128_t& b)
{
    uint128_t result = a;
    result.high() &= b.high();
    result.low() &= b.low();
    return result;
}

inline uint128_t operator|(const servus::uint128_t& a,
                           const servus::uint128_t& b)
{
    uint128_t result = a;
    result.high() |= b.high();
    result.low() |= b.low();
    return result;
}

SERVUS_API uint128_t make_uint128(const char* string);

inline uint128_t make_uint128(const std::string& string)
{
    return make_uint128(string.c_str());
}

SERVUS_API uint128_t make_UUID();
}

namespace std
{
template <>
struct hash<servus::uint128_t>
{
    typedef size_t result_type;

    result_type operator()(const servus::uint128_t& in) const
    {
        hash<uint64_t> forward;
        return forward(in.high()) ^ forward(in.low());
    }
};

inline string to_string(const servus::uint128_t& value)
{
    return value.getString();
}
}

#endif // SERVUS_UINT128_H