121 lines
3.7 KiB
C++
121 lines
3.7 KiB
C++
// assignment_request.cpp — see assignment_request.h. Pure: standard library only.
|
|
|
|
#include "assignment_request.h"
|
|
|
|
#include <cstddef>
|
|
|
|
namespace reasampler {
|
|
|
|
namespace {
|
|
|
|
constexpr const char* kMagic = "rsassign1";
|
|
|
|
// Append one length-prefixed field: <decimal-len> ':' <bytes>. Mirror of
|
|
// provenance's putField so the two seams share one wire idiom.
|
|
void putField(std::string& out, const std::string& field) {
|
|
out += std::to_string(field.size());
|
|
out += ':';
|
|
out += field;
|
|
}
|
|
|
|
// Cursor over the encoded string. All reads are bounds-checked; a short read fails
|
|
// the whole parse (ok_ latches false). Mirror of provenance's Cursor, trimmed to the
|
|
// three field kinds this record needs.
|
|
class Cursor {
|
|
public:
|
|
explicit Cursor(const std::string& s) : s_(s) {}
|
|
|
|
bool ok() const { return ok_; }
|
|
bool atEnd() const { return pos_ >= s_.size(); }
|
|
|
|
// Reads one length-prefixed field into `out`. Fails on a missing ':', an empty or
|
|
// non-numeric length, or a length that runs past the end.
|
|
bool field(std::string& out) {
|
|
if (!ok_) return false;
|
|
const std::size_t colon = s_.find(':', pos_);
|
|
if (colon == std::string::npos) return fail();
|
|
if (colon == pos_) return fail(); // empty length token
|
|
std::size_t len = 0;
|
|
for (std::size_t i = pos_; i < colon; ++i) {
|
|
const char c = s_[i];
|
|
if (c < '0' || c > '9') return fail();
|
|
len = len * 10 + static_cast<std::size_t>(c - '0');
|
|
}
|
|
const std::size_t start = colon + 1;
|
|
if (start + len > s_.size()) return fail();
|
|
out.assign(s_, start, len);
|
|
pos_ = start + len;
|
|
return true;
|
|
}
|
|
|
|
// Reads a length-prefixed field and parses it as a signed 64-bit decimal (an
|
|
// optional leading '-'). Fails on empty, non-digit, or trailing bytes.
|
|
bool fieldInt64(std::int64_t& out) {
|
|
std::string f;
|
|
if (!field(f)) return false;
|
|
if (f.empty()) return fail();
|
|
std::size_t i = 0;
|
|
bool neg = false;
|
|
if (f[0] == '-') {
|
|
neg = true;
|
|
i = 1;
|
|
if (f.size() == 1) return fail(); // bare "-"
|
|
}
|
|
std::int64_t v = 0;
|
|
for (; i < f.size(); ++i) {
|
|
const char c = f[i];
|
|
if (c < '0' || c > '9') return fail();
|
|
v = v * 10 + static_cast<std::int64_t>(c - '0');
|
|
}
|
|
out = neg ? -v : v;
|
|
return true;
|
|
}
|
|
|
|
// Consumes an exact literal at the cursor (the magic tag). Fails if absent.
|
|
bool literal(const char* lit) {
|
|
if (!ok_) return false;
|
|
std::size_t i = 0;
|
|
for (; lit[i] != '\0'; ++i) {
|
|
if (pos_ + i >= s_.size() || s_[pos_ + i] != lit[i]) return fail();
|
|
}
|
|
pos_ += i;
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
bool fail() {
|
|
ok_ = false;
|
|
return false;
|
|
}
|
|
|
|
const std::string& s_;
|
|
std::size_t pos_ = 0;
|
|
bool ok_ = true;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
std::string encodeAssignmentRequest(const AssignmentRequest& req) {
|
|
std::string out = kMagic;
|
|
putField(out, req.bankId);
|
|
putField(out, req.sampleId);
|
|
putField(out, std::to_string(req.generation));
|
|
return out;
|
|
}
|
|
|
|
std::optional<AssignmentRequest> decodeAssignmentRequest(const std::string& wire) {
|
|
Cursor cur(wire);
|
|
if (!cur.literal(kMagic)) return std::nullopt;
|
|
|
|
AssignmentRequest req;
|
|
if (!cur.field(req.bankId)) return std::nullopt;
|
|
if (!cur.field(req.sampleId)) return std::nullopt;
|
|
if (!cur.fieldInt64(req.generation)) return std::nullopt;
|
|
|
|
// Reject trailing garbage: a well-formed value ends exactly at the last field.
|
|
if (!cur.ok() || !cur.atEnd()) return std::nullopt;
|
|
return req;
|
|
}
|
|
|
|
} // namespace reasampler
|