#include "state.hpp" namespace notify { bool Registration::present() const { return owner != 0; } void Registration::clear() { owner = 0; cookie = 0; } void Slot::activate(int capacity_value) { live = true; epoch += 1; capacity = capacity_value; messages.clear(); registration.clear(); } void Slot::deactivate() { live = false; capacity = 0; messages.clear(); registration.clear(); } QueueView Slot::view() const { QueueView output; output.epoch = epoch; output.capacity = capacity; output.size = static_cast(messages.size()); output.owner = registration.owner; output.cookie = registration.cookie; return output; } Message Slot::remove_front() { Message output = messages.front(); messages.pop_front(); return output; } bool Runtime::Impl::queue_valid(int queue) { return queue >= 0 && queue < 4; } bool Runtime::Impl::owner_valid(int owner) { return owner >= 1 && owner <= 65535; } bool Runtime::Impl::capacity_valid(int capacity) { return capacity >= 1 && capacity <= 8; } bool Runtime::Impl::message_valid(int id, int value) { return id >= -32768 && id <= 32767 && value >= -1000000 && value <= 1000000; } bool Runtime::Impl::limit_valid(int limit) { return limit >= 0 && limit <= 8; } bool Runtime::Impl::index_valid(int index) { return index >= 0 && index <= 7; } Slot* Runtime::Impl::lookup(int queue) { if (!queue_valid(queue)) { return nullptr; } if (!slots[queue].live) { return nullptr; } return &slots[queue]; } const Slot* Runtime::Impl::lookup(int queue) const { if (!queue_valid(queue)) { return nullptr; } if (!slots[queue].live) { return nullptr; } return &slots[queue]; } Code Runtime::Impl::queue_error(int queue) const { if (!queue_valid(queue)) { return Code::invalid; } if (!slots[queue].live) { return Code::missing; } return Code::ok; } Runtime::Runtime() : impl_(new Impl) { } Runtime::~Runtime() = default; Stats Runtime::stats() const { Stats output; output.created = impl_->counters.created; output.closed = impl_->counters.closed; output.sent = impl_->counters.sent; output.received = impl_->counters.received; output.discarded = impl_->counters.discarded; output.armed = impl_->counters.armed; output.canceled = impl_->counters.canceled; output.notified = impl_->counters.notified; output.claimed = impl_->counters.claimed; return output; } Result Runtime::front(int queue) const { Result output; output.code = impl_->queue_error(queue); if (output.code != Code::ok) { return output; } const Slot* slot = impl_->lookup(queue); if (slot->messages.empty()) { output.code = Code::empty; return output; } output.value = slot->messages.front(); return output; } Result Runtime::at(int queue, int index) const { Result output; if (!Impl::queue_valid(queue) || !Impl::index_valid(index)) { output.code = Code::invalid; return output; } const Slot* slot = impl_->lookup(queue); if (slot == nullptr) { output.code = Code::missing; return output; } if (index >= static_cast(slot->messages.size())) { output.code = Code::empty; return output; } output.value = slot->messages[static_cast(index)]; return output; } Result Runtime::snapshot(int queue) const { Result output; output.code = impl_->queue_error(queue); if (output.code != Code::ok) { return output; } output.value = impl_->lookup(queue)->view(); return output; } Result Runtime::pending(int owner) const { Result output; if (!Impl::owner_valid(owner)) { output.code = Code::invalid; return output; } int count = 0; for (const Event& event : impl_->events) { if (event.owner == owner) { count += 1; } } output.value = count; return output; } }