#include "minor_router.hpp" #include #include namespace minorio { int Router::extract(const Device &object, std::uint64_t offset, std::uint64_t count, Bytes &out) { Bytes result; if (offset < object.data.size()) { const auto available = object.data.size() - static_cast(offset); const auto amount = static_cast(std::min(count, available)); const auto first = object.data.begin() + static_cast(offset); result.assign(first, first + amount); } const int result_size = static_cast(result.size()); out.swap(result); return result_size; } int Router::store(Device &object, std::uint64_t offset, const Bytes &data) { if (data.empty()) { return 0; } const auto room = object.capacity - static_cast(offset); const auto amount = std::min(room, data.size()); if (amount == 0) { return 0; } const auto finish = static_cast(offset) + amount; if (object.data.size() < finish) { object.data.resize(finish, 0); } auto destination = object.data.begin() + static_cast(offset); std::copy_n(data.begin(), amount, destination); return static_cast(amount); } int Router::read(int fd, std::uint64_t count, Bytes &out) { std::shared_ptr value; const int error = readable(fd, value); if (error != 0) { return error; } const int amount = extract(*value->object, value->cursor, count, out); value->cursor += static_cast(amount); return amount; } int Router::write(int fd, const Bytes &data) { std::shared_ptr value; const int error = writable(fd, value); if (error != 0) { return error; } if (data.size() > 4096) { return -22; } if (data.empty()) { return 0; } const auto offset = value->append ? value->object->data.size() : value->cursor; const int amount = store(*value->object, offset, data); value->cursor = offset + static_cast(amount); return amount; } int Router::pread(int fd, std::uint64_t offset, std::uint64_t count, Bytes &out) { std::shared_ptr value; const int error = readable(fd, value); if (error != 0) { return error; } if (offset > value->object->capacity) { return -22; } return extract(*value->object, offset, count, out); } int Router::pwrite(int fd, std::uint64_t offset, const Bytes &data) { std::shared_ptr value; const int error = writable(fd, value); if (error != 0) { return error; } if (offset > value->object->capacity) { return -22; } if (data.size() > 4096) { return -22; } return store(*value->object, offset, data); } int Router::seek(int fd, int whence, std::int64_t delta) { auto value = find_session(fd); if (!value) { return -9; } std::uint64_t base = 0; if (whence == 0) { base = 0; } else if (whence == 1) { base = value->cursor; } else if (whence == 2) { base = value->object->data.size(); } else { return -22; } std::uint64_t result = base; if (delta >= 0) { const auto amount = static_cast(delta); const auto room = value->object->capacity - base; if (amount > room) { return -22; } result += amount; } else { const auto amount = static_cast(-(delta + 1)) + 1; if (amount > base) { return -22; } result -= amount; } value->cursor = result; return static_cast(result); } int Router::resize(int fd, std::uint64_t length) { std::shared_ptr value; const int error = writable(fd, value); if (error != 0) { return error; } if (length > value->object->capacity) { return -22; } value->object->data.resize(static_cast(length), 0); return 0; } int Router::clear(int fd) { std::shared_ptr value; const int error = writable(fd, value); if (error != 0) { return error; } value->object->data.clear(); return 0; } int Router::peek(int minor, std::uint64_t offset, std::uint64_t count, Bytes &out) const { if (!valid_minor(minor)) { return -22; } const auto object = route(minor); if (!object) { return -2; } if (offset > object->capacity) { return -22; } return extract(*object, offset, count, out); } }