Byte Extraction

Иногда полезно получить 16 байтuuidнапрямую. Типичное использование выглядит следующим образом:<

boost::uuids::uuid u;
std::vector<char> v(u.size());
std::copy(u.begin(), u.end(), v.begin());

Примечание:повышение::uuids::uuid::size()всегда возвращается 16.

Ссылка

boost/uuid/uuid.hpp

Синопсис

namespace boost {
namespace uuids {
class uuid {
public:
    typedef uint8_t value_type;
    typedef uint8_t& reference;
    typedef uint8_t const& const_reference;
    typedef uint8_t* iterator;
    typedef uint8_t const* const_iterator;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    static constexpr size_type static_size() noexcept;
    // iteration
    iterator begin() noexcept;
    iterator end() noexcept;
    const_iterator begin() const noexcept;
    const_iterator end() const noexcept;
    constexpr size_type size() const noexcept;
    bool is_nil() const noexcept;
    enum variant_type {
        variant_ncs, // NCS backward compatibility
        variant_rfc_4122, // defined in RFC 4122 document
        variant_microsoft, // Microsoft Corporation backward compatibility
        variant_future // future definition
    };
    variant_type variant() const noexcept;
    enum version_type {
        version_unknown = -1,
        version_time_based = 1,
        version_dce_security = 2,
        version_name_based_md5 = 3,
        version_random_number_based = 4,
        version_name_based_sha1 = 5
    };
    version_type version() const noexcept;
    // Swap function
    void swap(uuid& rhs) noexcept;
    uint8_t data[static_size()];
};
// standard operators
bool operator==(uuid const& lhs, uuid const& rhs) noexcept;
bool operator!=(uuid const& lhs, uuid const& rhs) noexcept;
bool operator<(uuid const& lhs, uuid const& rhs) noexcept;
bool operator>(uuid const& lhs, uuid const& rhs) noexcept;
bool operator<=(uuid const& lhs, uuid const& rhs) noexcept;
bool operator>=(uuid const& lhs, uuid const& rhs) noexcept;
void swap(uuid& lhs, uuid& rhs) noexcept;
std::size_t hash_value(uuid const& u) noexcept;
}} // namespace boost::uuids

Размер

Размер ууида(в байтах) может быть получен либо вызовом функцииboost::uuids::uuid::size(), либо вызовом статической функцииboost::uuids:::uuid::static_size(), оба всегда возвращают 16.<

    boost::uuids::uuid u;
    assert(16 == u.size());
    assert(16 == boost::uuids::uuid::static_size());

Итерация

Предоставляются как итераторы, так и постоянные итераторы.<

    boost::uuids::uuid u;
    for (boost::uuids::uuid::const_iterator it=u.begin(); it!=u.end(); ++it) {
        boost::uuids::uuid::value_type v = *it;
    }
    for (boost::uuids::uuid::iterator it=u.begin(); it!=u.end(); ++it) {
        *it = 0;
    }

Ниль ууид

Функцияboost::uuids::uuid:::nil()возвращается истинной тогда и только тогда, когдаuuidравен {00000000-0000-0000-000000000000}.

Variant

Три битаuuidопределяют вариант.

    boost::uuids::uuid u;
    boost::uuids::uuid::variant_type v = u.variant();

Version

Четыре битаuuidопределяют вариант, то есть механизм, используемый для генерацииuuid.

    boost::uuids::uuid u;
    boost::uuids::uuid::version_type v = u.version();

Swap

бустер::uuids::uuid::swap()ибустер::uuids::swap().

    boost::uuids::uuid u1, u2;
    u1.swap(u2);
    swap(u1, u2);

Operators

Все стандартные числовые операторы определены для классаuuid. К ним относятся:<

    operator==
    operator!=
    operator<
    operator>
    operator<=
    operator>=

Хэш-функция

Эта функция позволяет использоватьuuids сбустером::hash<

boost::hash<boost::uuids::uuid> uuid_hasher;
std::size_t uuid_hash_value = uuid_hasher(boost::uuids::uuid());

boost/uuid/uuid_generators.hpp

Synopsis

#include <boost/uuid/nil_generator.hpp>
#include <boost/uuid/string_generator.hpp>
#include <boost/uuid/name_generator.hpp>
#include <boost/uuid/random_generator.hpp>

boost/uuid/nil_generator.hpp

Synopsis

namespace boost {
namespace uuids {
struct nil_generator {
    typedef uuid result_type;
    
    uuid operator()() const;
};
uuid nil_uuid();
}} //namespace boost::uuids

Классboost::uuids::nil_generatorвсегда генерирует niluuid.<

boost::uuids::nil_generator gen;
boost::uuids::uuid u = gen();
assert(u.is_nil() == true);
// or for convenience
boost::uuids::uuid u = boost::uuids::nil_uuid();
assert(u.is_nil() == true);

boost/uuid/string_generator.hpp

Повышениеboost::uuids::string_generatorкласс генерируетuuidиз строки.<

boost::uuids::string_generator gen;
boost::uuids::uuid u1 = gen("{01234567-89ab-cdef-0123-456789abcdef}");
boost::uuids::uuid u2 = gen(L"01234567-89ab-cdef-0123-456789abcdef");
boost::uuids::uuid u3 = gen(std::string("0123456789abcdef0123456789abcdef"));
boost::uuids::uuid u4 = gen(std::wstring(L"01234567-89ab-cdef-0123-456789abcdef"));

boost/uuid/name_generator.hpp

Synopsis

namespace boost {
namespace uuids {
class name_generator {
public:
    typedef uuid result_type;
    
    explicit name_generator(uuid const& namespace_uuid);
    uuid operator()(const char* name) const;
    uuid operator()(const wchar_t* name) const;
    tempate <typename ch, typename char_traits, typename alloc>
        uuid operator()(std::basic_string<ch, char_traits, alloc> const& name) const;
    uuid operator()(void const* buffer, std::size_t byte_count) const;
};
}} //namespace boost::uuids

Name Generator

boost::uuids::name_generatorclass генерирует имя на основеuuidиз пространства имен uuid и имени.<

boost::uuids::uuid dns_namespace_uuid; // initialize to {6ba7b810-9dad-11d1-80b4-00c04fd430c8}
boost::uuids::name_generator gen(dns_namespace_uuid);
boost::uuids::uuid u = gen("boost.org");

boost/uuid/random_generator.hpp

Synopsis

namespace boost {
namespace uuids {
template <typename UniformRandomNumberGenerator>
class basic_random_generator {
public:
    typedef uuid result_type;
    
    basic_random_generator();
    explicit basic_random_generator(UniformRandomNumberGenerator& gen);
    explicit basic_random_generator(UniformRandomNumberGenerator* pGen);
    
    uuid operator()();
};
typedef basic_random_generator<mt19937> random_generator;
}} // namespace boost::uuids

Случайный генератор

Повышение::uuids::basic_random_generatorкласс генерирует случайное число на основе uuid от генератора случайных чисел (тот, который соответствуетUniformRandomNumberGeneratorConcept.<

//default construct the random number generator and seed it
boost::uuids::basic_random_generator<boost::mt19937> gen;
boost::uuids::uuid u = gen();
//for convenience boost::uuids::random_generator
//is equivalent to boost::uuids::basic_random_generator<boost::mt19937>
boost::uuids::random_generator gen;
boost::uuids::uuid u = gen();
//use an existing random number generator
//pass either a reference or a pointer to the random number generator
boost::mt19937 ran;
boost::uuids::basic_random_generator<boost::mt19937> gen(&ran);
boost::uuids::uuid u = gen();

namespace boost {
namespace uuids {
template <typename ch, typename char_traits>
    std::basic_ostream<ch, char_traits>& operator<<(std::basic_ostream<ch, char_traits> &os, uuid const& u);
template <typename ch, typename char_traits>
    std::basic_istream<ch, char_traits>& operator>>(std::basic_istream<ch, char_traits> &is, uuid &u);
    
std::string to_string(uuid const& u);
std::wstring to_wstring(uuid const& u);
}} // namespace boost::uuids

boost::uuids::uuid u1; // initialize uuid
std::stringstream ss;
ss << u1;
boost::uuids::uuid u2;
ss >> u2;
assert(u1, u2);

boost::uuids::uuid u1; // initialize uuid
std::string s = boost::lexical_cast<std::string>(u);
boost::uuids::uuid u2 = boost::lexical_cast<boost::uuids::uuid>(s);
assert(u1 == u2);

boost::uuids::uuid u; // initialize uuid
std::string s1 = to_string(u);
std::wstring s2 = to_wstring(u);

namespace boost {
namespace uuids {
BOOST_CLASS_IMPLEMENTATION(boost::uuids::uuid, boost::serialization::primitive_type)
}} // namespace boost::uuids

boost::mt19937 ran;
ran.seed(time(NULL)); // one should likely seed in a better way
boost::uuids::basic_random_generator<boost::mt19937> gen(&ran);
boost::uuids::uuid u = gen();

// example of tagging an object with a uuid
// seeboost/libs/uuid/test/test_tagging.cpp
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
class object
{
public:
    object()
        : tag(boost::uuids::random_generator()())
        , state(0)
    {}
    explicit object(int state)
        : tag(boost::uuids::random_generator()())
        , state(state)
    {}
    object(object const& rhs)
        : tag(rhs.tag)
        , state(rhs.state)
    {}
    bool operator==(object const& rhs) const {
        return tag == rhs.tag;
    }
    object& operator=(object const& rhs) {
        tag = rhs.tag;
        state = rhs.state;
    }
    int get_state() const { return state; }
    void set_state(int new_state) { state = new_state; }
private:
    boost::uuids::uuid tag;
    int state;
};
object o1(1);
object o2 = o1;
o2.set_state(2);
assert(o1 == o2);
object o3(3);
assert(o1 != o3);
assert(o2 != o3);

// example using memcpy and aggregate initializers
// example of a class uuid seeboost/libs/uuid/test/test_uuid_class.cpp
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_generators.hpp>
{ // example using memcpy
    unsigned char uuid_data

---

©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007

Время компиляции файла: 2024-08-30 11:47:00
2025-05-20 09:02:08/0.0068249702453613/1