uint128_t.h

/* Copyright (c) 2010-2015, 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 <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;
#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
        {
            std::stringstream stream;
            stream << *this;
            return stream.str();
        }

    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();

}

#if __cplusplus >= 201103L || _MSC_VER > 1500
// C++11
#  define SERVUS_HASH_NAMESPACE_OPEN namespace std {
#  define SERVUS_HASH_NAMESPACE_CLOSE }
#  define SERVUS_HASH_USE_STRUCT
#  include <functional>
#elif defined __clang__ || defined __xlC__ || defined __GNUC__
// C++03 with clang and xlC
#  define SERVUS_HASH_NAMESPACE_OPEN namespace std { namespace tr1 {
#  define SERVUS_HASH_NAMESPACE_CLOSE }}
#  define SERVUS_HASH_USE_STRUCT
#  include <tr1/unordered_set>
#elif _MSC_VER < 1600
// C++03 with MSVC
#  define SERVUS_HASH_NAMESPACE_OPEN namespace std {
#  define SERVUS_HASH_NAMESPACE_CLOSE }
#  define SERVUS_HASH_USE_FUNCTORS
#else
// Unknown compiler, hash support is disabled.
#  define SERVUS_HASH_NONE
#endif

#ifndef SERVUS_HASH_NONE
SERVUS_HASH_NAMESPACE_OPEN
#  ifdef SERVUS_HASH_USE_STRUCT

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( ));
    }
};

#  else // SERVUS_HASH_USE_FUNCTORS

template<> inline size_t hash_compare< servus::uint128_t >::operator()
    ( const servus::uint128_t& key ) const
{
    return static_cast< size_t >( key.high() ^ key.low( ));
}

template<> inline size_t hash_value( const servus::uint128_t& key )
    { return static_cast< size_t >( key.high() ^ key.low( )); }
#  endif

SERVUS_HASH_NAMESPACE_CLOSE

#endif // SERVUS_HASH
#endif // SERVUS_UINT128_H