boost_uuid 0.1.0

Boost C++ library boost_uuid packaged using Zanbil
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#ifndef BOOST_UUID_BASIC_RANDOM_GENERATOR_HPP_INCLUDED
#define BOOST_UUID_BASIC_RANDOM_GENERATOR_HPP_INCLUDED

// Copyright 2010 Andy Tompkins
// Copyright 2017 James E. King III
// Copyright 2024 Peter Dimov
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt

#include <boost/uuid/uuid.hpp>
#include <boost/uuid/detail/random_provider.hpp>
#include <boost/uuid/detail/endian.hpp>
#include <boost/assert.hpp>
#include <type_traits>
#include <random>
#include <cstdint>

namespace boost {
namespace uuids {

template<class UniformRandomNumberGenerator>
class basic_random_generator
{
private:

    UniformRandomNumberGenerator* p_;
    UniformRandomNumberGenerator g_;

public:

    using result_type = uuid;

    // default constructor creates the random number generator and
    // if the UniformRandomNumberGenerator is a PseudoRandomNumberGenerator
    // then it gets seeded by a random_provider.
    basic_random_generator(): p_( 0 ), g_()
    {
        // seed the random number generator if it is capable
        seed( g_, 0 );
    }

    // keep a reference to a random number generator
    // don't seed a given random number generator
    explicit basic_random_generator( UniformRandomNumberGenerator& gen ): p_( &gen )
    {
    }

    // keep a pointer to a random number generator
    // don't seed a given random number generator
    explicit basic_random_generator( UniformRandomNumberGenerator* gen ): p_( gen )
    {
        BOOST_ASSERT( gen != 0 );
    }

    result_type operator()()
    {
        UniformRandomNumberGenerator& gen = p_? *p_: g_;

        result_type u;

        fill_data( gen, u );

        // set variant
        // must be 0b10xxxxxx
        *(u.begin() + 8) &= 0x3F;
        *(u.begin() + 8) |= 0x80;

        // set version
        // must be 0b0100xxxx
        *(u.begin() + 6) &= 0x0F; //0b00001111
        *(u.begin() + 6) |= 0x40; //0b01000000

        return u;
    }

private:

    template<class URNG> static void fill_data_impl( URNG& gen, uuid& u, std::false_type, std::false_type )
    {
        std::uniform_int_distribution<std::uint32_t> dist;

        detail::store_little_u32( u.data +  0, dist( gen ) );
        detail::store_little_u32( u.data +  4, dist( gen ) );
        detail::store_little_u32( u.data +  8, dist( gen ) );
        detail::store_little_u32( u.data + 12, dist( gen ) );
    }

    template<class URNG> static void fill_data_impl( URNG& gen, uuid& u, std::true_type, std::false_type )
    {
        detail::store_little_u32( u.data +  0, static_cast<std::uint32_t>( gen() ) );
        detail::store_little_u32( u.data +  4, static_cast<std::uint32_t>( gen() ) );
        detail::store_little_u32( u.data +  8, static_cast<std::uint32_t>( gen() ) );
        detail::store_little_u32( u.data + 12, static_cast<std::uint32_t>( gen() ) );
    }

    template<class URNG> static void fill_data_impl( URNG& gen, uuid& u, std::false_type, std::true_type )
    {
        detail::store_little_u64( u.data +  0, static_cast<std::uint64_t>( gen() ) );
        detail::store_little_u64( u.data +  8, static_cast<std::uint64_t>( gen() ) );
    }

    template<class URNG> static void fill_data( URNG& gen, uuid& u )
    {
        fill_data_impl( gen, u,
            std::integral_constant<bool, (URNG::min)() == 0 && (URNG::max)() == static_cast<std::uint32_t>( -1 )>(),
            std::integral_constant<bool, (URNG::min)() == 0 && (URNG::max)() == static_cast<std::uint64_t>( -1 )>()
        );
    }

    // Detect whether UniformRandomNumberGenerator has a seed() method which indicates that
    // it is a PseudoRandomNumberGenerator and needs a seed to initialize it.  This allows
    // basic_random_generator to take any type of UniformRandomNumberGenerator and still
    // meet the post-conditions for the default constructor.

    template<class MaybePseudoRandomNumberGenerator, class En = decltype( std::declval<MaybePseudoRandomNumberGenerator&>().seed() )>
    void seed( MaybePseudoRandomNumberGenerator& rng, int )
    {
        detail::random_provider seeder;
        rng.seed(seeder);
    }

    template<class MaybePseudoRandomNumberGenerator>
    void seed( MaybePseudoRandomNumberGenerator&, long )
    {
    }
};

}} // namespace boost::uuids

#endif // BOOST_UUID_BASIC_RANDOM_GENERATOR_HPP_INCLUDED