#include "handshake.hpp" #include #include #include namespace readyack { namespace { struct Ticket { Number id; std::vector data; }; struct Lane { bool active = false; Number width = 0, limit = 0; int phase = 0; Number id = 0, expected = 1; Number dirty = 0, accepted = 0, released = 0; std::array cells{}; std::vector deliveries; }; struct Unit { Number enable = 15, turn = 0; std::array lanes; }; using World = std::array; struct Event { char action; std::vector args; }; bool in(Number n, Number lo, Number hi) { return lo <= n && n <= hi; } Result bad(int code) { return Result{code, {}}; } void pack(std::vector& out, const Ticket& ticket) { out.push_back(ticket.id); out.push_back(static_cast(ticket.data.size())); out.insert(out.end(), ticket.data.begin(), ticket.data.end()); } Result reduce(World& state, const Event& event) { const auto& a = event.args; char op = event.action; if (!in(a[0], 0, 1)) return bad(1); bool board_only = op == 'S' || op == 'M' || op == 'K'; if (!board_only && !in(a[1], 0, 3)) return bad(1); if (op == 'C' && (!in(a[2], 1, 8) || !in(a[3], 1, 8))) return bad(1); if (op == 'W' && (!in(a[2], 0, 7) || !in(a[3], 0, 65535))) return bad(1); if ((op == 'P' || op == 'R') && !in(a[2], 1, 65535)) return bad(1); if (op == 'V' && !in(a[2], 0, 7)) return bad(1); if (op == 'T' && !in(a[2], 0, 8)) return bad(1); if (op == 'S' && !in(a[1], 0, 32)) return bad(1); if (op == 'M' && !in(a[1], 0, 15)) return bad(1); Unit& unit = state[static_cast(a[0])]; if (op == 'M') { unit.enable = a[1]; return {}; } if (op == 'K') return Result{0, {unit.enable, unit.turn}}; if (op == 'S') { Number creates = 0, clears = 0; for (Number i = 0; i < a[1]; ++i) { Number selected = unit.turn; unit.turn = (unit.turn + 1) % 4; Lane& lane = unit.lanes[static_cast(selected)]; if (!(unit.enable & (1LL << selected)) || !lane.active) continue; switch (lane.phase) { case 1: if (lane.deliveries.size() < static_cast(lane.limit)) { Ticket ticket{lane.id, {}}; ticket.data.assign(lane.cells.begin(), lane.cells.begin() + lane.width); lane.deliveries.push_back(std::move(ticket)); lane.phase = 2; ++lane.accepted; ++creates; } break; case 3: lane.phase = 0; ++lane.released; ++clears; break; default: break; } } return Result{0, {creates, clears, unit.turn}}; } Lane& lane = unit.lanes[static_cast(a[1])]; bool ready = lane.phase == 1 || lane.phase == 2; bool ack = lane.phase == 2 || lane.phase == 3; if (op == 'I') { return Result{0, {lane.active ? 1 : 0, lane.width, lane.limit, ready ? 1 : 0, ack ? 1 : 0, lane.id, lane.expected, lane.dirty, static_cast(lane.deliveries.size()), lane.accepted, lane.released}}; } if (op == 'C') { if (lane.phase || !lane.deliveries.empty()) return bad(3); lane = Lane{}; lane.active = true; lane.width = a[2]; lane.limit = a[3]; return {}; } if (!lane.active) return bad(2); switch (op) { case 'W': case 'V': if (a[2] >= lane.width) return bad(1); if (op == 'V') return Result{0, {lane.cells[static_cast(a[2])]}}; if (lane.phase) return bad(3); lane.cells[static_cast(a[2])] = a[3]; lane.dirty |= 1LL << a[2]; return {}; case 'P': if (lane.phase) return bad(3); if (lane.dirty != (1LL << lane.width) - 1) return bad(4); if (a[2] != lane.expected) return bad(5); lane.id = a[2]; lane.expected = a[2] == 65535 ? 1 : a[2] + 1; lane.dirty = 0; lane.phase = 1; return {}; case 'D': if (!ready) return bad(7); if (!ack) return bad(6); lane.phase = 3; return {}; case 'Q': { if (lane.deliveries.empty()) return bad(7); Result result; pack(result.values, lane.deliveries.front()); return result; } case 'T': { if (a[2] > static_cast(lane.deliveries.size())) return bad(7); Result result{0, {a[2]}}; for (Number i = 0; i < a[2]; ++i) pack(result.values, lane.deliveries[static_cast(i)]); lane.deliveries.erase(lane.deliveries.begin(), lane.deliveries.begin() + a[2]); return result; } case 'R': { if (lane.phase || !lane.deliveries.empty()) return bad(3); Number width = lane.width, capacity = lane.limit; lane = Lane{}; lane.active = true; lane.width = width; lane.limit = capacity; lane.expected = a[2]; return {}; } } return bad(1); } } struct System::Impl { std::vector history; Result call(char operation, std::vector arguments) { World rebuilt; for (const Event& event : history) reduce(rebuilt, event); Event next{operation, std::move(arguments)}; Result result = reduce(rebuilt, next); bool mutation = operation != 'I' && operation != 'V' && operation != 'K' && operation != 'Q'; if (result.code == 0 && mutation) history.push_back(std::move(next)); return result; } }; System::System() : impl_(new Impl) {} System::~System() = default; Result System::configure(Number b, Number c, Number w, Number n) { return impl_->call('C', {b,c,w,n}); } Result System::stage(Number b, Number c, Number i, Number v) { return impl_->call('W', {b,c,i,v}); } Result System::publish(Number b, Number c, Number g) { return impl_->call('P', {b,c,g}); } Result System::withdraw(Number b, Number c) { return impl_->call('D', {b,c}); } Result System::step(Number b, Number q) { return impl_->call('S', {b,q}); } Result System::set_mask(Number b, Number m) { return impl_->call('M', {b,m}); } Result System::get_mask(Number b) const { return impl_->call('K', {b}); } Result System::word(Number b, Number c, Number i) const { return impl_->call('V', {b,c,i}); } Result System::peek(Number b, Number c) const { return impl_->call('Q', {b,c}); } Result System::drain(Number b, Number c, Number n) { return impl_->call('T', {b,c,n}); } Result System::inspect(Number b, Number c) const { return impl_->call('I', {b,c}); } Result System::reset(Number b, Number c, Number g) { return impl_->call('R', {b,c,g}); } }