ActorId.h

Go to the documentation of this file.

 
#ifndef QB_ACTORID_H
#define QB_ACTORID_H
#include <algorithm>
#include <bitset>
#include <cstdint>
#include <limits>
#include <unordered_set>
#include <vector>
// include from qb
#include <qb/io.h>
#include <qb/system/container/unordered_set.h>
#include <qb/utility/build_macros.h>
#include <qb/utility/prefix.h>
 
namespace qb {

using CoreId    = uint16_t;

using ServiceId = uint16_t;

using TypeId    = uint16_t;

using EventId   = TypeId;

constexpr size_t MaxCores = 256;

class CoreIdBitSet {
private:
    std::bitset<MaxCores> _bits;
 
public:
    CoreIdBitSet() = default;

    explicit CoreIdBitSet(const qb::unordered_set<CoreId> &coreIds) {
        for (const auto id : coreIds) {
            _bits.set(id);
        }
    }

    CoreIdBitSet(std::initializer_list<CoreId> ids) {
        for (const auto id : ids) {
            _bits.set(id);
        }
    }

    [[nodiscard]] const std::bitset<MaxCores> &
    bits() const noexcept {
        return _bits;
    }

    [[nodiscard]] bool
    contains(CoreId id) const noexcept {
        return id < MaxCores && _bits.test(id);
    }

    void
    insert(CoreId id) noexcept {
        if (id < MaxCores) {
            _bits.set(id);
        }
    }

    void
    emplace(CoreId id) noexcept {
        insert(id);
    }

    void
    remove(CoreId id) noexcept {
        if (id < MaxCores) {
            _bits.reset(id);
        }
    }

    void
    clear() noexcept {
        _bits.reset();
    }

    [[nodiscard]] bool
    empty() const noexcept {
        return _bits.none();
    }

    [[nodiscard]] size_t
    size() const noexcept {
        return _bits.count();
    }

    [[nodiscard]] std::vector<CoreId>
    to_vector() const {
        std::vector<CoreId> result;
        result.reserve(_bits.count());
 
        for (size_t i = 0; i < MaxCores; ++i) {
            if (_bits.test(i)) {
                result.push_back(static_cast<CoreId>(i));
            }
        }
 
        return result;
    }

    [[nodiscard]] qb::unordered_set<CoreId>
    to_unordered_set() const {
        qb::unordered_set<CoreId> result;
 
        for (size_t i = 0; i < MaxCores; ++i) {
            if (_bits.test(i)) {
                result.insert(static_cast<CoreId>(i));
            }
        }
 
        return result;
    }

    [[nodiscard]] qb::unordered_set<CoreId>
    raw() const {
        return to_unordered_set();
    }
 
    // Iteration support
    class iterator {
    private:
        const CoreIdBitSet &_set;
        size_t              _pos;
 
        // Advance to the next set bit
        void
        advance() {
            while (_pos < MaxCores && !_set._bits.test(_pos)) {
                ++_pos;
            }
        }
 
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type        = CoreId;
        using difference_type   = std::ptrdiff_t;
        using pointer           = const CoreId *;
        using reference         = const CoreId &;

        iterator(const CoreIdBitSet &set, size_t pos)
            : _set(set)
            , _pos(pos) {
            advance();
        }

        CoreId
        operator*() const {
            return static_cast<CoreId>(_pos);
        }

        iterator &
        operator++() {
            ++_pos;
            advance();
            return *this;
        }

        iterator
        operator++(int) {
            iterator tmp = *this;
            ++(*this);
            return tmp;
        }

        bool
        operator==(const iterator &other) const {
            return &_set == &other._set && _pos == other._pos;
        }

        bool
        operator!=(const iterator &other) const {
            return !(*this == other);
        }
    };

    [[nodiscard]] iterator
    begin() const {
        return iterator(*this, 0);
    }

    [[nodiscard]] iterator
    end() const {
        return iterator(*this, MaxCores);
    }
};
 
// Define CoreIdSet as our new efficient implementation
using CoreIdSet = CoreIdBitSet;

class ActorId {
    template <typename T>
    friend struct std::hash;
 
    friend class CoreInitializer;
    friend class SharedCoreCommunication;
    friend class VirtualCore;
    friend class Actor;
    friend class Service;
 
private:
    ServiceId _service_id;
    CoreId    _core_id;
 
protected:
    ActorId(ServiceId id, CoreId index) noexcept;
 
public:
    static constexpr uint32_t  NotFound     = 0;
    static constexpr ServiceId BroadcastSid = (std::numeric_limits<ServiceId>::max)();

    ActorId() noexcept;
    ActorId(uint32_t id) noexcept;

    [[nodiscard]] operator uint32_t() const noexcept;

    [[nodiscard]] ServiceId sid() const noexcept;

    [[nodiscard]] CoreId index() const noexcept;

    [[nodiscard]] bool is_broadcast() const noexcept;

    [[nodiscard]] bool is_valid() const noexcept;
};

class BroadcastId : public ActorId {
public:
    BroadcastId() = delete;
    explicit BroadcastId(uint32_t const core_id) noexcept
        : ActorId(BroadcastSid, static_cast<CoreId>(core_id)) {}
};

using ActorIdList   = std::vector<ActorId>;

using ActorIdSet    = std::unordered_set<ActorId>;

using core_id       = CoreId;

using service_id    = ServiceId;

using actor_id      = ActorId;

using broadcast_id  = BroadcastId;

using actor_id_list = ActorIdList;

using actor_is_set  = ActorIdSet;

using core_id_set   = CoreIdSet;
#ifdef QB_LOGGER
qb::io::log::stream &operator<<(qb::io::log::stream &os, qb::ActorId const &id);
#endif
} // namespace qb
 
namespace std {
template <>
struct hash<qb::ActorId> {
    std::size_t
    operator()(qb::ActorId const &val) const noexcept {
        return static_cast<uint32_t>(val);
    }
};
} // namespace std
 
#endif // QB_ACTORID_H