uuid.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <cstring>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/error.h>
#include <promeki/core/array.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class UUID {
        public:
                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 UUID fromString(const char *string, Error *err = nullptr);
 
                UUID() : d{} { }
 
                UUID(const UUID &u) : d(u.d) { }
 
                UUID(const UUID &&u) : d(std::move(u.d)) { }
 
                UUID(const DataFormat &val) : d(val) { }
 
                UUID(const DataFormat &&val) : d(std::move(val)) { }
 
                explicit UUID(const char *str) : d(fromString(str).data()) { }
 
                explicit UUID(const String &str) : d(fromString(str.cstr()).data()) { }
 
                UUID &operator=(const UUID &val) {
                        d = val.d;
                        return *this;
                }
 
                UUID &operator=(const UUID &&val) {
                        d = std::move(val.d);
                        return *this;
                }
 
                UUID &operator=(const DataFormat &val) {
                        d = val;
                        return *this;
                }
 
                UUID &operator=(const DataFormat &&val) {
                        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();
                }
 
        private:
                DataFormat d;
};
 
PROMEKI_NAMESPACE_END