uuid.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdint>
#include <iomanip>
#include <istream>
#include <ostream>
 
namespace ignite {

class uuid {
public:
    constexpr uuid() noexcept = default;

    constexpr uuid(std::int64_t most, std::int64_t least) noexcept
        : most(most)
        , least(least) {}

    [[nodiscard]] static uuid random();

    [[nodiscard]] constexpr std::int64_t get_most_significant_bits() const noexcept { return most; }

    [[nodiscard]] constexpr std::int64_t get_least_significant_bits() const noexcept { return least; }

    [[nodiscard]] constexpr std::int32_t version() const noexcept {
        return static_cast<std::int32_t>((most >> 12) & 0x0f);
    }

    [[nodiscard]] constexpr std::int32_t variant() const noexcept {
        auto least0 = static_cast<uint64_t>(least);
        return static_cast<std::int32_t>((least0 >> (64 - (least0 >> 62))) & (least >> 63));
    }

    [[nodiscard]] constexpr int compare(const uuid &other) const noexcept {
        if (most != other.most) {
            return most < other.most ? -1 : 1;
        }
        if (least != other.least) {
            return least < other.least ? -1 : 1;
        }
        return 0;
    }
 
private:
    std::int64_t most = 0;

    std::int64_t least = 0;
};

constexpr bool operator==(const uuid &lhs, const uuid &rhs) noexcept {
    return lhs.compare(rhs) == 0;
}

constexpr bool operator!=(const uuid &lhs, const uuid &rhs) noexcept {
    return lhs.compare(rhs) != 0;
}

constexpr bool operator<(const uuid &lhs, const uuid &rhs) noexcept {
    return lhs.compare(rhs) < 0;
}

constexpr bool operator<=(const uuid &lhs, const uuid &rhs) noexcept {
    return lhs.compare(rhs) <= 0;
}

constexpr bool operator>(const uuid &lhs, const uuid &rhs) noexcept {
    return lhs.compare(rhs) > 0;
}

constexpr bool operator>=(const uuid &lhs, const uuid &rhs) noexcept {
    return lhs.compare(rhs) >= 0;
}

template<typename C, typename T>
::std::basic_ostream<C, T> &operator<<(std::basic_ostream<C, T> &os, const uuid &uuid) {
    auto msb = uuid.get_most_significant_bits();
    auto lsb = uuid.get_least_significant_bits();
 
    auto part1 = static_cast<std::uint32_t>(msb >> 32);
    auto part2 = static_cast<std::uint16_t>(msb >> 16);
    auto part3 = static_cast<std::uint16_t>(msb);
    auto part4 = static_cast<std::uint16_t>(lsb >> 48);
    uint64_t part5 = lsb & 0x0000FFFFFFFFFFFFU;
 
    std::ios_base::fmtflags saved_flags = os.flags();
 
    // clang-format off
    os  << std::hex 
        << std::setfill<C>('0') << std::setw(8)  << part1 << '-'
        << std::setfill<C>('0') << std::setw(4)  << part2 << '-'
        << std::setfill<C>('0') << std::setw(4)  << part3 << '-'
        << std::setfill<C>('0') << std::setw(4)  << part4 << '-'
        << std::setfill<C>('0') << std::setw(12) << part5;
    // clang-format on
 
    os.flags(saved_flags);
 
    return os;
}

template<typename C, typename T>
::std::basic_istream<C, T> &operator>>(std::basic_istream<C, T> &is, uuid &result) {
    std::uint64_t parts[5];
 
    std::ios_base::fmtflags saved_flags = is.flags();
 
    is >> std::hex;
 
    for (int i = 0; i < 4; ++i) {
        C delim;
 
        is >> parts[i] >> delim;
 
        if (delim != static_cast<C>('-')) {
            return is;
        }
    }
 
    is >> parts[4];
 
    is.flags(saved_flags);
 
    result =
        uuid(std::int64_t((parts[0] << 32) | (parts[1] << 16) | parts[2]), std::int64_t((parts[3] << 48) | parts[4]));
 
    return is;
}
 
} // namespace ignite