#include "record.hpp" #include "internal.hpp" #include #include namespace inline_record { struct Store::Impl { std::map records; Totals ledger; }; namespace { Result failed(const char* error) { Result result; result.error = error; return result; } bool valid_id(std::int64_t id) { return id >= 0 && id <= 7; } bool valid_position(std::int64_t position) { return position >= 0 && position <= 64; } Result describe(const detail::Record& record) { Result result; result.token = record.token(); result.count = static_cast(record.count()); result.tag = record.tag(); result.bytes = static_cast(record.size()); result.checksum = record.checksum(); return result; } } Store::Store() : impl_(new Impl) { } Store::~Store() = default; Result Store::replace(std::int64_t id, std::int64_t n, std::int64_t tag, std::int64_t budget) { if (!valid_id(id)) { return failed("BAD_ID"); } if (n < 0 || n > 64) { return failed("BAD_SIZE"); } if (tag < 0 || tag > 65535) { return failed("BAD_TAG"); } if (budget < 16 || budget > 272) { return failed("BAD_BUDGET"); } const std::int64_t required = 16 + n * 4; if (budget < required) { return failed("NOMEM"); } const std::uint32_t identity = static_cast(impl_->ledger.next); detail::Record fresh(identity, static_cast(tag), static_cast(n)); auto old = impl_->records.find(id); if (old != impl_->records.end()) { impl_->ledger.bytes -= static_cast(old->second.size()); impl_->records.erase(old); ++impl_->ledger.frees; --impl_->ledger.live; } impl_->records.emplace(id, std::move(fresh)); ++impl_->ledger.allocations; ++impl_->ledger.live; ++impl_->ledger.next; impl_->ledger.bytes += required; return Result{}; } Result Store::fill(std::int64_t id, std::int64_t start, std::int64_t count, std::int64_t value) { if (!valid_id(id)) { return failed("BAD_ID"); } if (!valid_position(start)) { return failed("BAD_START"); } if (!valid_position(count)) { return failed("BAD_COUNT"); } if (value < -1000000 || value > 1000000) { return failed("BAD_VALUE"); } auto target = impl_->records.find(id); if (target == impl_->records.end()) { return failed("ABSENT"); } const std::int64_t capacity = static_cast(target->second.count()); if (start > capacity || count > capacity - start) { return failed("RANGE"); } target->second.fill(static_cast(start), static_cast(count), static_cast(value)); return Result{}; } Result Store::copy(std::int64_t dst, std::int64_t src, std::int64_t from, std::int64_t to, std::int64_t count) { if (!valid_id(dst)) { return failed("BAD_ID"); } if (!valid_id(src)) { return failed("BAD_SOURCE"); } if (!valid_position(from)) { return failed("BAD_FROM"); } if (!valid_position(to)) { return failed("BAD_TO"); } if (!valid_position(count)) { return failed("BAD_COUNT"); } auto destination = impl_->records.find(dst); auto source = impl_->records.find(src); if (destination == impl_->records.end()) { return failed("ABSENT"); } if (source == impl_->records.end()) { return failed("NO_SOURCE"); } const std::int64_t source_count = static_cast(source->second.count()); const std::int64_t destination_count = static_cast(destination->second.count()); if (from > source_count || count > source_count - from) { return failed("RANGE"); } if (to > destination_count || count > destination_count - to) { return failed("RANGE"); } destination->second.copy_from(source->second, static_cast(from), static_cast(to), static_cast(count)); return Result{}; } Result Store::drop(std::int64_t id) { if (!valid_id(id)) { return failed("BAD_ID"); } auto found = impl_->records.find(id); if (found == impl_->records.end()) { return failed("ABSENT"); } impl_->ledger.bytes -= static_cast(found->second.size()); impl_->records.erase(found); ++impl_->ledger.frees; --impl_->ledger.live; return Result{}; } Result Store::info(std::int64_t id) const { if (!valid_id(id)) { return failed("BAD_ID"); } auto found = impl_->records.find(id); if (found == impl_->records.end()) { return failed("ABSENT"); } return describe(found->second); } Result Store::get(std::int64_t id, std::int64_t index) const { if (!valid_id(id)) { return failed("BAD_ID"); } if (index < 0 || index > 63) { return failed("BAD_INDEX"); } auto found = impl_->records.find(id); if (found == impl_->records.end()) { return failed("ABSENT"); } if (index >= static_cast(found->second.count())) { return failed("RANGE"); } Result result; result.value = found->second.get(static_cast(index)); return result; } Result Store::byte(std::int64_t id, std::int64_t offset) const { if (!valid_id(id)) { return failed("BAD_ID"); } if (offset < 0 || offset > 271) { return failed("BAD_OFFSET"); } auto found = impl_->records.find(id); if (found == impl_->records.end()) { return failed("ABSENT"); } if (offset >= static_cast(found->second.size())) { return failed("RANGE"); } Result result; result.value = found->second.byte(static_cast(offset)); return result; } Totals Store::totals() const { return impl_->ledger; } }