#include <iostream>
#include <boost/parameter.hpp>
#include <boost/type_traits.hpp>
#include <boost/mpl/integral_c.hpp>

enum negatives_options {
    default_option,
    option_1,
    option_2,
    option_3,
};

struct fixedlength_base_t { };
struct negatives_base_t { };
struct secure_base_t { };

template <std::size_t Bits>
struct fixedlength_t: public boost::mpl::size_t<Bits>,
    public fixedlength_base_t { };

template <negatives_options Opt>
struct negatives_t: public boost::mpl::integral_c<negatives_options, Opt>,
    public negatives_base_t { };

template <bool T>
struct secure_t: public boost::mpl::bool_<T>, public secure_base_t { };

BOOST_PARAMETER_TEMPLATE_KEYWORD(fixedlength)
BOOST_PARAMETER_TEMPLATE_KEYWORD(secure)
BOOST_PARAMETER_TEMPLATE_KEYWORD(negatives)
BOOST_PARAMETER_TEMPLATE_KEYWORD(allocator)

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

typedef boost::parameter::parameters<
    optional<deduced<tag::fixedlength>, is_base_of<fixedlength_base_t, _> >,
    optional<deduced<tag::secure>, is_base_of<secure_base_t, _> >,
    optional<deduced<tag::negatives>, is_base_of<negatives_base_t, _> >,
    optional<deduced<tag::allocator>, is_class<_> >
> integer_signature;

template <
    class A0 = boost::parameter::void_,
    class A1 = boost::parameter::void_,
    class A2 = boost::parameter::void_,
    class A3 = boost::parameter::void_
>
class integer_t {
    public:
    typedef typename integer_signature::bind<A0,A1,A2,A3>::type args;

    typedef typename boost::parameter::binding<args, tag::fixedlength,
        fixedlength_t<0> >::type fixedlength;
    typedef typename boost::parameter::binding<args, tag::negatives,
        negatives_t<default_option> >::type negatives;
    typedef typename boost::parameter::binding<args, tag::secure,
        secure_t<false> >::type secure;
    typedef typename boost::parameter::binding<args, tag::allocator,
        std::allocator<int> >::type allocator;

    static void report() {
        using std::cout;
        using std::endl;
        cout << "Length: " << fixedlength::value << endl;
        cout << "Negatives option: " << negatives::value << endl;
        cout << "Secure: " << (secure::value ? "true" : "false") << endl;
        cout << "Allocator type size: " << sizeof(typename allocator::value_type)
            << endl;
    }
};

int main() {
    integer_t<
        std::allocator<int>,
        negatives_t<option_1>,
        fixedlength_t<128>
    >::report();
    return 0;
}