uint128_t.h

/* Copyright (c) 2010, Cedric Stalder <cedric.stalder@gmail.com>
 *               2010-2012, Stefan Eilemann <eile@eyescale.ch>
 *                    2010, Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 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 LUNCHBOX_UINT128_H
#define LUNCHBOX_UINT128_H

#include <lunchbox/api.h>
#include <sstream>

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

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

    class uint128_t
    {
    public:
        uint128_t( const uint64_t low_ = 0 ) 
            : _high( 0 ), _low( low_ ) {}

        explicit 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; }

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

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

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

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

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

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

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

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

        bool operator >= ( const 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 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();
        }

        static LUNCHBOX_API const uint128_t ZERO;

    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 uint128_t operator+ ( const 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 uint128_t& a, const uint128_t& b ) 
    {
        uint128_t result = a;
        result += b;
        return result;
    };

    inline uint128_t operator- ( const 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 uint128_t& a, const uint128_t& b )
    {
        uint128_t result = a;
        result.high() &= b.high();
        result.low() &= b.low();
        return result;
    }

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

    LUNCHBOX_API uint128_t make_uint128( const char* string );
}
#endif // LUNCHBOX_UINT128_H