FM / detail

/usr/include/boost/random/detail

Name	Size	Mode	Actions
auto_link.hpp	959	0644	edit dl rm
config.hpp	538	0644	edit dl rm
const_mod.hpp	5566	0644	edit dl rm
disable_warnings.hpp	823	0644	edit dl rm
enable_warnings.hpp	552	0644	edit dl rm
generator_bits.hpp	874	0644	edit dl rm
generator_seed_seq.hpp	861	0644	edit dl rm
gray_coded_qrng.hpp	4662	0644	edit dl rm
integer_log2.hpp	2181	0644	edit dl rm
int_float_pair.hpp	4178	0644	edit dl rm
iterator_mixin.hpp	1303	0644	edit dl rm
large_arithmetic.hpp	3615	0644	edit dl rm
niederreiter_base2_table.hpp	36285	0644	edit dl rm
operators.hpp	3673	0644	edit dl rm
polynomial.hpp	13305	0644	edit dl rm
ptr_helper.hpp	1534	0644	edit dl rm
qrng_base.hpp	8659	0644	edit dl rm
seed.hpp	5020	0644	edit dl rm
seed_impl.hpp	14283	0644	edit dl rm
signed_unsigned_tools.hpp	2535	0644	edit dl rm
sobol_table.hpp	234013	0644	edit dl rm
uniform_int_float.hpp	2123	0644	edit dl rm
vector_io.hpp	1792	0644	edit dl rm

Edit: /usr/include/boost/random/detail/seed.hpp (5020B)

#ifndef BOOST_RANDOM_DETAIL_SEED_HPP
#define BOOST_RANDOM_DETAIL_SEED_HPP

#include <boost/config.hpp>

// Sun seems to have trouble with the use of SFINAE for the
// templated constructor.  So does Borland.
#if !defined(BOOST_NO_SFINAE) && !defined(__SUNPRO_CC) && !defined(__BORLANDC__)

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/mpl/bool.hpp>

namespace boost {
namespace random {
namespace detail {

template<class T>
struct disable_seed : boost::disable_if<boost::is_arithmetic<T> > {};

template<class Engine, class T>
struct disable_constructor : disable_seed<T> {};

template<class Engine>
struct disable_constructor<Engine, Engine> {};

#define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
    template<class Generator>                                           \
    explicit Self(Generator& gen, typename ::boost::random::detail::disable_constructor<Self, Generator>::type* = 0)

#define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen)    \
    template<class Generator>                                       \
    void seed(Generator& gen, typename ::boost::random::detail::disable_seed<Generator>::type* = 0)

#define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
    template<class SeedSeq>                                             \
    explicit Self(SeedSeq& seq, typename ::boost::random::detail::disable_constructor<Self, SeedSeq>::type* = 0)

#define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)   \
    template<class SeedSeq>                                     \
    void seed(SeedSeq& seq, typename ::boost::random::detail::disable_seed<SeedSeq>::type* = 0)

#define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
    explicit Self(const T& x)

#define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
    void seed(const T& x)
}
}
}

#else

#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/mpl/bool.hpp>

#define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
    Self(Self& other) { *this = other; }                                \
    Self(const Self& other) { *this = other; }                          \
    template<class Generator>                                           \
    explicit Self(Generator& gen) {                                     \
        boost_random_constructor_impl(gen, ::boost::is_arithmetic<Generator>());\
    }                                                                   \
    template<class Generator>                                           \
    void boost_random_constructor_impl(Generator& gen, ::boost::mpl::false_)

#define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen)    \
    template<class Generator>                                       \
    void seed(Generator& gen) {                                     \
        boost_random_seed_impl(gen, ::boost::is_arithmetic<Generator>());\
    }\
    template<class Generator>\
    void boost_random_seed_impl(Generator& gen, ::boost::mpl::false_)

#define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
    Self(Self& other) { *this = other; }                                \
    Self(const Self& other) { *this = other; }                          \
    template<class SeedSeq>                                             \
    explicit Self(SeedSeq& seq) {                                       \
        boost_random_constructor_impl(seq, ::boost::is_arithmetic<SeedSeq>());\
    }                                                                   \
    template<class SeedSeq>                                             \
    void boost_random_constructor_impl(SeedSeq& seq, ::boost::mpl::false_)

#define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)           \
    template<class SeedSeq>                                             \
    void seed(SeedSeq& seq) {                                           \
        boost_random_seed_impl(seq, ::boost::is_arithmetic<SeedSeq>()); \
    }                                                                   \
    template<class SeedSeq>                                             \
    void boost_random_seed_impl(SeedSeq& seq, ::boost::mpl::false_)

#define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
    explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::mpl::true_()); }\
    void boost_random_constructor_impl(const T& x, ::boost::mpl::true_)

#define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
    void seed(const T& x) { boost_random_seed_impl(x, ::boost::mpl::true_()); }\
    void boost_random_seed_impl(const T& x, ::boost::mpl::true_)

#endif

/* boost random/detail/seed.hpp header file * * Copyright Steven Watanabe 2009 * 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 for most recent version including documentation. * * $Id$ */ #ifndef BOOST_RANDOM_DETAIL_SEED_HPP #define BOOST_RANDOM_DETAIL_SEED_HPP #include // Sun seems to have trouble with the use of SFINAE for the // templated constructor. So does Borland. #if !defined(BOOST_NO_SFINAE) && !defined(__SUNPRO_CC) && !defined(__BORLANDC__) #include #include #include namespace boost { namespace random { namespace detail { template struct disable_seed : boost::disable_if > {}; template struct disable_constructor : disable_seed {}; template struct disable_constructor {}; #define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \ template \ explicit Self(Generator& gen, typename ::boost::random::detail::disable_constructor::type* = 0) #define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen) \ template \ void seed(Generator& gen, typename ::boost::random::detail::disable_seed::type* = 0) #define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq) \ template \ explicit Self(SeedSeq& seq, typename ::boost::random::detail::disable_constructor::type* = 0) #define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq) \ template \ void seed(SeedSeq& seq, typename ::boost::random::detail::disable_seed::type* = 0) #define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x) \ explicit Self(const T& x) #define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \ void seed(const T& x) } } } #else #include #include #define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \ Self(Self& other) { *this = other; } \ Self(const Self& other) { *this = other; } \ template \ explicit Self(Generator& gen) { \ boost_random_constructor_impl(gen, ::boost::is_arithmetic());\ } \ template \ void boost_random_constructor_impl(Generator& gen, ::boost::mpl::false_) #define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen) \ template \ void seed(Generator& gen) { \ boost_random_seed_impl(gen, ::boost::is_arithmetic());\ }\ template\ void boost_random_seed_impl(Generator& gen, ::boost::mpl::false_) #define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq) \ Self(Self& other) { *this = other; } \ Self(const Self& other) { *this = other; } \ template \ explicit Self(SeedSeq& seq) { \ boost_random_constructor_impl(seq, ::boost::is_arithmetic());\ } \ template \ void boost_random_constructor_impl(SeedSeq& seq, ::boost::mpl::false_) #define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq) \ template \ void seed(SeedSeq& seq) { \ boost_random_seed_impl(seq, ::boost::is_arithmetic()); \ } \ template \ void boost_random_seed_impl(SeedSeq& seq, ::boost::mpl::false_) #define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x) \ explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::mpl::true_()); }\ void boost_random_constructor_impl(const T& x, ::boost::mpl::true_) #define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \ void seed(const T& x) { boost_random_seed_impl(x, ::boost::mpl::true_()); }\ void boost_random_seed_impl(const T& x, ::boost::mpl::true_) #endif #endif