detail/options.hpp

Go to the documentation of this file.

/*
    The Extended Integer (XInt) Library
    A fast, portable C++ library for multi-precision integer math
    Copyright 2010 by Chad Nelson

    Distributed under the Boost Software License, Version 1.0.
    See accompanying file LICENSE_1_0.txt or copy at
        http://www.boost.org/LICENSE_1_0.txt

    See http://www.boost.org/libs/xint for library home page.
*/

#ifndef BOOST_INCLUDED_XINT_INTEGER_OPTIONS_HPP
#define BOOST_INCLUDED_XINT_INTEGER_OPTIONS_HPP

namespace boost {
namespace xint {

#ifndef BOOST_XINT_DOXYGEN_IGNORE
BOOST_PARAMETER_TEMPLATE_KEYWORD(fixedlength_tag)
BOOST_PARAMETER_TEMPLATE_KEYWORD(threadsafe_tag)
BOOST_PARAMETER_TEMPLATE_KEYWORD(secure_tag)
BOOST_PARAMETER_TEMPLATE_KEYWORD(nothrow_tag)
BOOST_PARAMETER_TEMPLATE_KEYWORD(allocator_tag)
BOOST_PARAMETER_TEMPLATE_KEYWORD(sign_tag)
#endif // BOOST_XINT_DOXYGEN_IGNORE

using boost::is_base_of;
using boost::mpl::_;
using boost::parameter::binding;
using boost::parameter::optional;
using boost::parameter::deduced;

#ifndef BOOST_XINT_DOXYGEN_IGNORE
namespace detail {
enum negative_policy {
    // This says it's signed, and is the default.
    p_signed_type,

    // This says it's unsigned, and to use the default negative policy (modulus
    // for fixed-length, throw_exception for variable-length).
    p_unsigned_type,

    // These say that it's unsigned, and to use the specific negative policy
    // named.
    p_modulus,
    p_throw_exception, // or return Not-a-Number for nothrow types
    p_force_zero,
    p_force_absolute
};
} // namespace detail
#endif // BOOST_XINT_DOXYGEN_IGNORE

namespace options {

#ifndef BOOST_XINT_DOXYGEN_IGNORE
struct fixedlength_base { };
struct threadsafe_base { };
struct secure_base { };
struct nothrow_base { };
struct sign_base { };
#endif // BOOST_XINT_DOXYGEN_IGNORE


template <bitsize_t Bits> struct fixedlength: public fixedlength_base, public
    boost::mpl::integral_c<bitsize_t, Bits> { };


struct threadsafe: public threadsafe_base, public boost::mpl::bool_<true> { };

struct copy_on_write: public threadsafe_base, public boost::mpl::bool_<false>{};


struct secure: public secure_base, public boost::mpl::bool_<true> { };

struct nothrow: public nothrow_base, public boost::mpl::bool_<true> { };


struct negative_allowed: public sign_base, public
    boost::mpl::integral_c<detail::negative_policy, detail::p_signed_type>
    { };

struct negative_not_allowed: public sign_base, public
    boost::mpl::integral_c<detail::negative_policy, detail::p_unsigned_type>
    { };

struct negative_modulus: public sign_base, public
    boost::mpl::integral_c<detail::negative_policy, detail::p_modulus>
    { };

struct negative_exception: public sign_base, public
    boost::mpl::integral_c<detail::negative_policy, detail::p_throw_exception>
    { };

struct negative_zero: public sign_base, public
    boost::mpl::integral_c<detail::negative_policy, detail::p_force_zero>
    { };

struct negative_absolute: public sign_base, public
    boost::mpl::integral_c<detail::negative_policy, detail::p_force_absolute>
    { };

#ifndef BOOST_XINT_DOXYGEN_IGNORE
typedef parameter::parameters<
    optional<deduced<tag::fixedlength_tag>, is_base_of<fixedlength_base, _> >,
    optional<deduced<tag::threadsafe_tag>,  is_base_of<threadsafe_base, _> >,
    optional<deduced<tag::secure_tag>,      is_base_of<secure_base, _> >,
    optional<deduced<tag::nothrow_tag>,     is_base_of<nothrow_base, _> >,
    optional<deduced<tag::sign_tag>,        is_base_of<sign_base, _> >,
    optional<deduced<tag::allocator_tag>,   is_class<_> >
> integer_signature;
#endif

} // namespace options

namespace detail {

// integer_t data

#ifdef BOOST_XINT_DOXYGEN_IGNORE
    // The documentation should see a simplified version of the template
    // parameters.
    #define BOOST_XINT_INITIAL_APARAMS ...
    #define BOOST_XINT_CLASS_APARAMS ...
    #define BOOST_XINT_CLASS_BPARAMS other
    #define BOOST_XINT_APARAMS ...
    #define BOOST_XINT_BPARAMS other
#else
    #define BOOST_XINT_INITIAL_APARAMS \
        class A0 = parameter::void_, \
        class A1 = parameter::void_, \
        class A2 = parameter::void_, \
        class A3 = parameter::void_, \
        class A4 = parameter::void_, \
        class A5 = parameter::void_
    #define BOOST_XINT_CLASS_APARAMS class A0, class A1, class A2, class A3, \
        class A4, class A5
    #define BOOST_XINT_APARAMS A0, A1, A2, A3, A4, A5
    #define BOOST_XINT_CLASS_BPARAMS class B0, class B1, class B2, class B3, \
        class B4, class B5
    #define BOOST_XINT_BPARAMS B0, B1, B2, B3, B4, B5
#endif

#ifndef BOOST_XINT_DOXYGEN_IGNORE

template<BOOST_XINT_CLASS_APARAMS>
class integer_t_data {
    public:
    typedef typename options::integer_signature::bind<BOOST_XINT_APARAMS>::type
        args;
    typedef const typename binding<args, tag::fixedlength_tag,
        options::fixedlength<0> >::type BitsType;
    typedef const typename binding<args, tag::threadsafe_tag, mpl::true_>::type
        ThreadsafeType;
    typedef const typename binding<args, tag::secure_tag, mpl::false_>::type
        SecureType;
    typedef const typename binding<args, tag::nothrow_tag, mpl::false_>::type
        NothrowType;
    typedef const typename binding<args, tag::sign_tag,
        options::negative_allowed>::type SignType;

    static const bitsize_t Bits;
    static const bool Threadsafe, Secure, Nothrow, Signed;
    typedef typename binding<args, tag::allocator_tag,
        std::allocator<detail::digit_t> >::type Alloc;
    typedef raw_integer_t<BitsType::value, SecureType::value, Alloc> datatype;

    integer_t_data() { }
    integer_t_data(const datatype& copy): data(copy) { }
    template <bitsize_t B, bool S, class A>
    integer_t_data(const raw_integer_t<B,S,A>& copy): data(copy) { }


    datatype& _data() { return data; }
    const datatype& _data() const { return data; }
    std::size_t _get_length() const { return data.length; }
    detail::digit_t _get_digit(std::size_t i) const { return data[i]; }
    void _make_unique() { data.make_unique(); }

    protected:
    datatype data;
};

template<BOOST_XINT_CLASS_APARAMS>
const bitsize_t integer_t_data<BOOST_XINT_APARAMS>::Bits =
    integer_t_data<BOOST_XINT_APARAMS>::BitsType::value;

template<BOOST_XINT_CLASS_APARAMS>
const bool integer_t_data<BOOST_XINT_APARAMS>::Threadsafe =
    integer_t_data<BOOST_XINT_APARAMS>::ThreadsafeType::value;

template<BOOST_XINT_CLASS_APARAMS>
const bool integer_t_data<BOOST_XINT_APARAMS>::Secure =
    integer_t_data<BOOST_XINT_APARAMS>::SecureType::value;

template<BOOST_XINT_CLASS_APARAMS>
const bool integer_t_data<BOOST_XINT_APARAMS>::Nothrow =
    integer_t_data<BOOST_XINT_APARAMS>::NothrowType::value;

template<BOOST_XINT_CLASS_APARAMS>
const bool integer_t_data<BOOST_XINT_APARAMS>::Signed =
    (integer_t_data<BOOST_XINT_APARAMS>::SignType::value == p_signed_type);

// class nan_functions, to handle nothrow-specific Not-a-Number stuff

template <bool Nothrow, typename T, BOOST_XINT_CLASS_APARAMS>
class nan_functions { };

template <typename T, BOOST_XINT_CLASS_APARAMS>
class nan_functions<false, T, BOOST_XINT_APARAMS>: virtual public
    integer_t_data<BOOST_XINT_APARAMS>
{
    public:
    bool is_nan() const { return false; }
};

template <typename T, BOOST_XINT_CLASS_APARAMS>
class nan_functions<true, T, BOOST_XINT_APARAMS>: virtual public
    integer_t_data<BOOST_XINT_APARAMS>
{
    public:
    bool is_nan() const {
        return integer_t_data<BOOST_XINT_APARAMS>::data.is_nan();
    }

    static T nan() { return get_nan<T>(); }
};

// class fixed_functions, to handle fixed-specific stuff

template <bitsize_t Bits, typename T, BOOST_XINT_CLASS_APARAMS>
class fixed_functions: virtual public integer_t_data<BOOST_XINT_APARAMS> {
    using integer_t_data<BOOST_XINT_APARAMS>::Threadsafe;
    using integer_t_data<BOOST_XINT_APARAMS>::Nothrow;
    using integer_t_data<BOOST_XINT_APARAMS>::Signed;

    public:
    T operator~() const {
        if (Nothrow) {
            if (integer_t_data<BOOST_XINT_APARAMS>::data.is_nan())
                return detail::get_nan<T>();
            BOOST_XINT_TRY {
                T r(~integer_t_data<BOOST_XINT_APARAMS>::data);
                if (Threadsafe == true) r._make_unique();
                if (!Signed) r.data.negative = false;
                else r.data.negative = !r.data.negative;
                return BOOST_XINT_MOVE(r);
            } BOOST_XINT_CATCH {
                return detail::get_nan<T>();
            }
        } else {
            T r(~integer_t_data<BOOST_XINT_APARAMS>::data);
            if (Threadsafe == true) r._make_unique();
            if (!Signed) r.data.negative = false;
            else r.data.negative = !r.data.negative;
            return BOOST_XINT_MOVE(r);
        }
    }
};

template <typename T, BOOST_XINT_CLASS_APARAMS>
class fixed_functions<0, T, BOOST_XINT_APARAMS>: virtual public
    integer_t_data<BOOST_XINT_APARAMS>
{
    // Nothing needed here at present.
};

// class unsigned_negative_functions, for... well, unsigned negatives. :-)

template <negative_policy P, BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions { };

template <BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions<p_signed_type, BOOST_XINT_APARAMS> {
    public:
    void _fix_negative_unsigned() { } // Nothing to do for signed numbers
};

template <BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions<p_unsigned_type, BOOST_XINT_APARAMS>: virtual
    public integer_t_data<BOOST_XINT_APARAMS>, public
    unsigned_negative_functions<(integer_t_data<BOOST_XINT_APARAMS>::BitsType::
    value != 0 ? p_modulus : p_throw_exception), BOOST_XINT_APARAMS>
{
    // Don't need anything here, it inherits from the proper default item
    // (modulus for fixed-length, throw_exception for variable-length)
};

template <BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions<p_modulus, BOOST_XINT_APARAMS>: virtual
    public integer_t_data<BOOST_XINT_APARAMS>
{
    // Types using unsigned_modulus must be fixedlength too.
    typedef typename integer_t_data<BOOST_XINT_APARAMS>::BitsType BitsType;
    BOOST_STATIC_ASSERT(BitsType::value != 0);

    public:
    void _fix_negative_unsigned() {
        typename integer_t_data<BOOST_XINT_APARAMS>::datatype&
            data(integer_t_data<BOOST_XINT_APARAMS>::_data());
        data = ~data;
        ++data;
    }
};

template <BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions<p_throw_exception, BOOST_XINT_APARAMS>:
    virtual public integer_t_data<BOOST_XINT_APARAMS>
{
    public:
    void _fix_negative_unsigned() {
        if (integer_t_data<BOOST_XINT_APARAMS>::NothrowType::value) {
            integer_t_data<BOOST_XINT_APARAMS>::_data().make_nan();
        } else {
            exception_handler<>::call(__FILE__, __LINE__,
                exceptions::cannot_represent("unsigned negative value"));
        }
    }
};

template <BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions<p_force_zero, BOOST_XINT_APARAMS>: virtual
    public integer_t_data<BOOST_XINT_APARAMS>
{
    public:
    void _fix_negative_unsigned() {
        typename integer_t_data<BOOST_XINT_APARAMS>::datatype&
            data(integer_t_data<BOOST_XINT_APARAMS>::_data());
        data.set(0);
    }
};

template <BOOST_XINT_CLASS_APARAMS>
class unsigned_negative_functions<p_force_absolute, BOOST_XINT_APARAMS>: virtual
    public integer_t_data<BOOST_XINT_APARAMS>
{
    public:
    void _fix_negative_unsigned() {
        typename integer_t_data<BOOST_XINT_APARAMS>::datatype&
            data(integer_t_data<BOOST_XINT_APARAMS>::_data());
        data.negative = false;
    }
};

#endif // BOOST_XINT_DOXYGEN_IGNORE

} // namespace detail
} // namespace xint
} // namespace boost

#endif // BOOST_INCLUDED_XINT_INTEGER_OPTIONS_HPP