#include "stream.hpp" #include namespace captured { Device::ByteQueue::ByteQueue() : bytes_(16, 0) { } void Device::ByteQueue::configure(std::size_t cap) { bytes_.assign(cap, 0); head_ = 0; size_ = 0; } std::size_t Device::ByteQueue::capacity() const { return bytes_.size(); } std::size_t Device::ByteQueue::size() const { return size_; } std::size_t Device::ByteQueue::available() const { return capacity() - size_; } std::size_t Device::ByteQueue::position(std::size_t offset) const { const std::size_t tail_room = capacity() - head_; if (offset < tail_room) { return head_ + offset; } return offset - tail_room; } void Device::ByteQueue::push(const Bytes& data, std::int64_t mode) { const Bytes converted = transform(data, mode); for (std::uint8_t byte : converted) { const std::size_t destination = position(size_); bytes_[destination] = byte; ++size_; } } Bytes Device::ByteQueue::prefix(std::size_t count) const { Bytes output; output.reserve(count); for (std::size_t offset = 0; offset < count; ++offset) { const std::size_t source = position(offset); output.push_back(bytes_[source]); } return output; } void Device::ByteQueue::discard(std::size_t count) { if (count == 0) { return; } const std::size_t remaining = size_ - count; if (remaining == 0) { head_ = 0; size_ = 0; return; } head_ = position(count); size_ = remaining; } Device::Device() : transactions_(4) { } bool Device::valid_id(std::uint64_t id) { return id >= 1 && id <= 4294967295ULL; } Device::Transaction* Device::find(std::uint64_t id) { for (Transaction& transaction : transactions_) { if (transaction.used && transaction.id == id) { return &transaction; } } return nullptr; } const Device::Transaction* Device::find(std::uint64_t id) const { for (const Transaction& transaction : transactions_) { if (transaction.used && transaction.id == id) { return &transaction; } } return nullptr; } Device::Transaction* Device::vacant() { for (Transaction& transaction : transactions_) { if (!transaction.used) { return &transaction; } } return nullptr; } std::size_t Device::active_count() const { std::size_t count = 0; for (const Transaction& transaction : transactions_) { if (transaction.used) { ++count; } } return count; } Result Device::error(int status) { Result result; result.status = status; return result; } Snapshot Device::missing(int status) { Snapshot snapshot; snapshot.status = status; return snapshot; } Snapshot Device::describe(const Transaction& transaction) { Snapshot snapshot; snapshot.id = transaction.id; snapshot.total = transaction.total; snapshot.accepted = transaction.accepted; snapshot.remaining = transaction.total - transaction.accepted; snapshot.captured_mode = transaction.mode; return snapshot; } int Device::reset(std::uint64_t cap) { if (cap < 1 || cap > 4096) { return -22; } queue_.configure(static_cast(cap)); for (Transaction& transaction : transactions_) { transaction = Transaction{}; } mode_ = 0; accepted_ = 0; consumed_ = 0; completed_ = 0; canceled_ = 0; return 0; } int Device::set_mode(std::int64_t mode) { if (mode < 0 || mode > 2) { return -22; } mode_ = mode; return 0; } std::int64_t Device::get_mode() const { return mode_; } std::uint64_t Device::capacity() const { return queue_.capacity(); } int Device::begin(std::uint64_t id, std::uint64_t total) { if (!valid_id(id)) { return -22; } if (total > 65535) { return -7; } if (find(id) != nullptr) { return -17; } Transaction* transaction = vacant(); if (transaction == nullptr) { return -28; } transaction->used = true; transaction->id = id; transaction->total = total; transaction->accepted = 0; transaction->mode = mode_; return 0; } Result Device::append(std::uint64_t id, const Bytes& data, std::uint64_t budget) { if (!valid_id(id)) { return error(-22); } Transaction* transaction = find(id); if (transaction == nullptr) { return error(-2); } if (budget > 4096) { return error(-22); } if (data.size() > 65535) { return error(-7); } const std::uint64_t remaining = transaction->total - transaction->accepted; if (data.size() > remaining) { return error(-90); } std::size_t count = data.size(); count = std::min(count, static_cast(budget)); count = std::min(count, queue_.available()); const Bytes prefix(data.begin(), data.begin() + count); queue_.push(prefix, transaction->mode); transaction->accepted += count; accepted_ += data.size(); Result result; result.count = count; return result; } int Device::finish(std::uint64_t id) { if (!valid_id(id)) { return -22; } Transaction* transaction = find(id); if (transaction == nullptr) { return -2; } if (transaction->accepted != transaction->total) { return -115; } *transaction = Transaction{}; ++completed_; return 0; } int Device::cancel(std::uint64_t id) { if (!valid_id(id)) { return -22; } Transaction* transaction = find(id); if (transaction == nullptr) { return -2; } *transaction = Transaction{}; ++canceled_; return 0; } Result Device::peek(std::uint64_t count) const { if (count > 4096) { return error(-22); } if (count == 0) { return Result{}; } if (queue_.size() == 0) { return error(-11); } Result result; result.count = std::min(count, static_cast(queue_.size())); result.data = queue_.prefix(static_cast(result.count)); return result; } Result Device::read(std::uint64_t count) { Result result = peek(count); if (result.status != 0) { return result; } queue_.discard(static_cast(result.count)); consumed_ += result.count; return result; } Stats Device::stats() const { Stats result; result.accepted = accepted_; result.consumed = consumed_; result.completed = completed_; result.canceled = canceled_; result.buffered = queue_.size(); result.active = active_count(); return result; } Snapshot Device::inspect(std::uint64_t id) const { if (!valid_id(id)) { return missing(-22); } const Transaction* transaction = find(id); if (transaction == nullptr) { return missing(-2); } return describe(*transaction); } std::vector Device::active_ids() const { std::vector ids; ids.reserve(active_count()); for (const Transaction& transaction : transactions_) { if (transaction.used) { ids.push_back(transaction.id); } } std::sort(ids.begin(), ids.end()); return ids; } }