uuid.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdint>
#include <cstring>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/array.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class UUID {
        public:
                PROMEKI_DATATYPE(UUID, DataTypeUUID, 1)
 
                
                using DataFormat = Array<uint8_t, 16>;
 
                static UUID generate(int version = 4);
 
                static UUID generateV1();
 
                static UUID generateV3(const UUID &ns, const String &name);
 
                static UUID generateV4();
 
                static UUID generateV5(const UUID &ns, const String &name);
 
                static UUID generateV7(int64_t timestampMs = -1);
 
                static Result<UUID> fromString(const String &string);
 
                UUID() : d{} {}
 
                UUID(const UUID &u) : d(u.d) {}
 
                UUID(UUID &&u) noexcept : d(std::move(u.d)) {}
 
                UUID(const DataFormat &val) : d(val) {}
 
                UUID(DataFormat &&val) noexcept : d(std::move(val)) {}
 
                UUID &operator=(const UUID &val) {
                        d = val.d;
                        return *this;
                }
 
                UUID &operator=(UUID &&val) noexcept {
                        d = std::move(val.d);
                        return *this;
                }
 
                UUID &operator=(const DataFormat &val) {
                        d = val;
                        return *this;
                }
 
                UUID &operator=(DataFormat &&val) noexcept {
                        d = std::move(val);
                        return *this;
                }
 
                bool operator==(const UUID &other) const { return d == other.d; }
 
                bool operator!=(const UUID &other) const { return d != other.d; }
 
                bool operator<(const UUID &other) const { return std::memcmp(d.data(), other.d.data(), 16) < 0; }
 
                bool operator>(const UUID &other) const { return std::memcmp(d.data(), other.d.data(), 16) > 0; }
 
                bool operator<=(const UUID &other) const { return std::memcmp(d.data(), other.d.data(), 16) <= 0; }
 
                bool operator>=(const UUID &other) const { return std::memcmp(d.data(), other.d.data(), 16) >= 0; }
 
                operator String() const { return toString(); }
 
                bool isValid() const { return !d.isZero(); }
 
                int version() const {
                        if (!isValid()) return 0;
                        return (d[6] >> 4) & 0x0F;
                }
 
                String toString() const;
 
                const DataFormat &data() const { return d; }
 
                const uint8_t *raw() const { return d.data(); }
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<UUID> readFromStream(DataStream &s);
 
        private:
                DataFormat d;
};
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::UUID);
 
#endif // PROMEKI_ENABLE_CORE