Int128.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <duds/BuildConfig.h>
#include <cstdint>
#include <sstream>

/*
#include <type_traits>
namespace std {
    template <>
    struct is_integral<__int128> : public true_type {
        //static constexpr bool value = true;
    };
    template <>
    struct is_integral<unsigned __int128> : public true_type {
        //static constexpr bool value = true;
    };
    template <>
    struct is_integral<boost::multiprecision::int128_t> : public true_type {
        //static constexpr bool value = true;
    };
    template <>
    struct is_integral<boost::multiprecision::uint128_t> : public true_type {
        //static constexpr bool value = true;
    };
}
*/

namespace duds { namespace data {

#ifdef HAVE_INT128
typedef __int128  int128_t;

std::istream &operator >> (std::istream &is, int128_t &b);
std::ostream &operator << (std::ostream &os, int128_t const &b);

#else
typedef boost::multiprecision::int128_t  int128_t;
#endif

template <class I, class M>
struct LargeIntWrapper {
    /*
private:
    LargeIntWrapper(const double &v);
    LargeIntWrapper &operator = (double const &b);
    */
public:
    I value;
    LargeIntWrapper() = default;
    LargeIntWrapper(const LargeIntWrapper &liw) = default;
    //template <class N, typename std::enable_if<std::is_integral<N>::value>::type >
    //constexpr LargeIntWrapper(const N &v) : value(v) { }
    constexpr LargeIntWrapper(const I &v) : value(v) { }
    /*
    operator I const & () const {
        return value;
    }
    */
    LargeIntWrapper &operator = (LargeIntWrapper const &b) {
        value = b.value;
        return *this;
    }
    /*
    template <class N, typename std::enable_if<std::is_integral<N>::value>::type >
    LargeIntWrapper &operator = (N const &b) {
        value = b;
        return *this;
    }
    */
    //template <>
    LargeIntWrapper &operator = (I const &b) {
        value = b;
        return *this;
    }
    bool operator == (LargeIntWrapper const &b) const {
        return value == b.value;
    }
    bool operator != (LargeIntWrapper const &b) const {
        return value != b.value;
    }
    bool operator > (LargeIntWrapper const &b) const {
        return value > b.value;
    }
    bool operator < (LargeIntWrapper const &b) const {
        return value < b.value;
    }
    bool operator >= (LargeIntWrapper const &b) const {
        return value >= b.value;
    }
    bool operator <= (LargeIntWrapper const &b) const {
        return value <= b.value;
    }
    LargeIntWrapper operator + (LargeIntWrapper const &b) const {
        return value + b.value;
    }
    LargeIntWrapper operator - (LargeIntWrapper const &b) const {
        return value - b.value;
    }
    LargeIntWrapper operator * (LargeIntWrapper const &b) const {
        return value * b.value;
    }
    LargeIntWrapper operator / (LargeIntWrapper const &b) const {
        return value / b.value;
    }
    LargeIntWrapper operator % (LargeIntWrapper const &b) const {
        return value % b.value;
    }
    LargeIntWrapper &operator += (LargeIntWrapper const &b) {
        return value += b.value;
    }
    LargeIntWrapper &operator -= (LargeIntWrapper const &b) {
        return value -= b.value;
    }
    LargeIntWrapper &operator *= (LargeIntWrapper const &b) {
        return value *= b.value;
    }
    LargeIntWrapper &operator /= (LargeIntWrapper const &b) {
        return value /= b.value;
    }
    LargeIntWrapper &operator %= (LargeIntWrapper const &b) {
        return value %= b.value;
    }
    friend std::istream &operator >> (std::istream &is, LargeIntWrapper &b) {
        return is >> b.value;
    }
    friend std::ostream &operator << (std::ostream &os, LargeIntWrapper const &b) {
        return os << b.value;
    }
private:
    friend class boost::serialization::access;
    template <class A>
    void save(A &a, const unsigned int) const {
        std::ostringstream os;
        os << std::hex << *this;
        std::string s(os.str());
        a << boost::serialization::make_nvp("value", s);
    }
    template <class A>
    void load(A &a, const unsigned int) {
        std::string s;
        a >> boost::serialization::make_nvp("value", s);
        std::istringstream is(s);
        is >> std::hex >> *this;
    }
    BOOST_SERIALIZATION_SPLIT_MEMBER();
};


typedef LargeIntWrapper<int128_t, boost::multiprecision::int128_t>  int128_w;

} }