id.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
/*
 * Project: RAVENNAKIT (RAVENNA / AES67 / ST2110-30 SDK)
 * Copyright (c) 2024-2025 Sound on Digital
 *
 * This file is part of RAVENNAKIT.
 *
 * RAVENNAKIT is dual-licensed:
 *   1) Under the terms of the GNU Affero General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version (the "AGPL License"); and
 *   2) Under a commercial license from Sound on Digital, for customers who
 *      cannot (or do not wish to) comply with the AGPL License terms.
 *
 * If you obtained this file under the AGPL License, you may redistribute it
 * and/or modify it under the terms of the AGPL License. See the LICENSE
 * file in the project root for details.
 *
 * For commercial licensing, support, and other inquiries, please visit:
 *
 *     https://ravennakit.com
 *
 */
 
#pragma once
 
#include "ravennakit/core/assert.hpp"
 
#include <cstdint>
#include <atomic>
 
namespace rav {

class Id {
  public:
    class Generator {
      public:
        Generator() = default;
 
        Generator(const Generator&) = delete;
        Generator& operator=(const Generator&) = delete;
 
        Generator(Generator&&) = delete;
        Generator& operator=(Generator&&) = delete;

        [[nodiscard]] Id next() {
            RAV_ASSERT(next_id_ != 0, "Next ID is 0, which is reserved for invalid IDs");
            RAV_ASSERT(next_id_ != std::numeric_limits<uint64_t>::max(), "The next ID is at the maximum value");
            return Id(next_id_.fetch_add(1));
        }

        void reset() {
            next_id_ = 1;
        }
 
      private:
        std::atomic<uint64_t> next_id_ {1};
    };
 
    Id() = default;

    explicit Id(const uint64_t int_id) : id_(int_id) {}
 
    Id(const Id& other) = default;
    Id& operator=(const Id& other) = default;
 
    Id(Id&& other) noexcept = default;
    Id& operator=(Id&& other) noexcept = default;

    [[nodiscard]] bool is_valid() const noexcept {
        return id_ != 0;
    }

    [[nodiscard]] uint64_t value() const {
        return id_;
    }

    [[nodiscard]] std::string to_string() const {
        return std::to_string(id_);
    }
 
    bool operator==(const uint64_t value) const {
        return id_ == value;
    }
 
    friend bool operator==(const Id& lhs, const Id& rhs) {
        return lhs.id_ == rhs.id_;
    }
 
    friend bool operator!=(const Id& lhs, const Id& rhs) {
        return !(lhs == rhs);
    }

    static Id get_next_process_wide_unique_id() noexcept {
        static Generator gen;
        return gen.next();
    }
 
  private:
    uint64_t id_ {};
};
 
static_assert(std::atomic<Id>::is_always_lock_free);
static_assert(std::is_trivially_copyable_v<Id>);
 
}  // namespace rav