#include "reader.hpp" #include #include #include #include #include #include using exception_reader::Event; using exception_reader::Reader; using exception_reader::Request; using exception_reader::Result; using exception_reader::Store; namespace { std::vector words(const std::string &line) { std::istringstream input(line); std::vector output; std::string word; while (input >> word) { output.push_back(word); } return output; } int nibble(char value) { if (value >= '0' && value <= '9') { return value - '0'; } if (value >= 'a' && value <= 'f') { return value - 'a' + 10; } if (value >= 'A' && value <= 'F') { return value - 'A' + 10; } return -1; } bool decode(const std::string &source, std::string &output) { output.clear(); if (source == "-") { return true; } if (source.size() % 2 != 0) { return false; } for (std::size_t at = 0; at < source.size(); at += 2) { const int high = nibble(source[at]); const int low = nibble(source[at + 1]); if (high < 0 || low < 0) { return false; } output.push_back(static_cast((high << 4) | low)); } return true; } std::string encode(const std::string &source) { static const char digits[] = "0123456789abcdef"; if (source.empty()) { return "-"; } std::string output; output.reserve(source.size() * 2); for (unsigned char byte : source) { output.push_back(digits[byte >> 4]); output.push_back(digits[byte & 15]); } return output; } template bool parse_number(const std::string &text, Number &output) { if (text.empty()) { return false; } const char *first = text.data(); const char *last = first + text.size(); const auto result = std::from_chars(first, last, output); return result.ec == std::errc{} && result.ptr == last; } void print_result(const Result &result) { std::cout << "Q " << exception_reader::status_name(result.status) << ' ' << result.lines << ' ' << result.bytes << ' ' << result.longest << ' ' << result.digest << ' ' << result.index_value << ' ' << result.opened << ' ' << result.closed << ' ' << result.live << '\n'; } class Observer { public: explicit Observer(std::size_t capacity) : store_(capacity), reader_(store_) {} bool execute(const std::vector &parts) { if (parts.empty()) { return true; } if (parts[0] == "P") { return put(parts); } if (parts[0] == "A") { return append(parts); } if (parts[0] == "O") { return open(parts); } if (parts[0] == "D") { return duplicate(parts); } if (parts[0] == "R") { return read(parts); } if (parts[0] == "C") { return close(parts); } if (parts[0] == "J") { return jump(parts); } if (parts[0] == "I") { return inspect(parts); } if (parts[0] == "Q") { return query(parts); } if (parts[0] == "S") { return state(parts); } return false; } private: bool put(const std::vector &parts) { if (parts.size() != 3 || parts[1].empty()) { return false; } std::string bytes; if (!decode(parts[2], bytes)) { return false; } store_.put(parts[1], bytes); std::cout << "P " << parts[1] << '\n'; return true; } bool query(const std::vector &parts) { if (parts.size() != 6 || parts[1].empty()) { return false; } unsigned use_index = 0; std::size_t chunk = 0; long long fault_after = 0; if (!parse_number(parts[3], use_index) || use_index > 1 || !parse_number(parts[4], chunk) || !parse_number(parts[5], fault_after)) { return false; } const Request request{parts[1], parts[2], use_index != 0, chunk, fault_after}; print_result(reader_.run(request)); return true; } bool append(const std::vector &parts) { if (parts.size() != 3 || !store_.contains(parts[1])) { return false; } std::string bytes; if (!decode(parts[2], bytes)) { return false; } store_.append(parts[1], bytes); std::cout << "A " << parts[1] << ' ' << store_.file_size(parts[1]) << '\n'; return true; } bool open(const std::vector &parts) { if (parts.size() != 2) return false; try { const int handle = store_.open(parts[1]); std::cout << "O " << handle << '\n'; } catch (const exception_reader::Missing &) { std::cout << "O MISSING\n"; } catch (const exception_reader::Exhausted &) { std::cout << "O EXHAUSTED\n"; } return true; } bool duplicate(const std::vector &parts) { int handle = 0; if (parts.size() != 2 || !parse_number(parts[1],handle)) return false; try { const int next = store_.clone(handle); std::cout << "D " << next << '\n'; } catch (const exception_reader::BadHandle &) { std::cout << "D BAD_HANDLE\n"; } catch (const exception_reader::Exhausted &) { std::cout << "D EXHAUSTED\n"; } return true; } bool read(const std::vector &parts) { int handle = 0; std::size_t limit = 0; long long fault = 0; if (parts.size() != 4 || !parse_number(parts[1],handle) || !parse_number(parts[2],limit) || limit == 0 || !parse_number(parts[3],fault)) return false; try { const std::string piece = store_.read(handle,limit,fault); std::cout << "R " << encode(piece) << '\n'; } catch (const exception_reader::BadHandle &) { std::cout << "R BAD_HANDLE\n"; } catch (const exception_reader::ReadFault &) { std::cout << "R READ_ERROR\n"; } return true; } bool close(const std::vector &parts) { int handle = 0; if (parts.size() != 2 || !parse_number(parts[1],handle)) return false; try { store_.close(handle); std::cout << "C " << handle << '\n'; } catch (const exception_reader::BadHandle &) { std::cout << "C BAD_HANDLE\n"; } return true; } bool jump(const std::vector &parts) { int handle = 0; std::size_t offset = 0; if (parts.size() != 3 || !parse_number(parts[1],handle) || !parse_number(parts[2],offset)) return false; try { store_.seek(handle,offset); std::cout << "J " << offset << '\n'; } catch (const exception_reader::BadHandle &) { std::cout << "J BAD_HANDLE\n"; } catch (const std::invalid_argument &) { std::cout << "J RANGE_ERROR\n"; } return true; } bool inspect(const std::vector &parts) { int handle = 0; if (parts.size() != 2 || !parse_number(parts[1],handle)) return false; try { const std::size_t position = store_.position(handle); const std::size_t remaining = store_.remaining(handle); std::cout << "I " << position << ' ' << remaining << '\n'; } catch (const exception_reader::BadHandle &) { std::cout << "I BAD_HANDLE\n"; } return true; } bool state(const std::vector &parts) { if (parts.size() != 1) { return false; } const std::vector events = store_.events(); std::cout << "S " << store_.live() << ' ' << events.size() - previous_event_ << '\n'; for (std::size_t at = previous_event_; at < events.size(); ++at) { const Event &event = events[at]; std::cout << "E " << event.kind << ' ' << event.handle << ' ' << event.amount << '\n'; } previous_event_ = events.size(); return true; } Store store_; Reader reader_; std::size_t previous_event_ = 0; }; } int main() { Observer observer(3); std::string line; while (std::getline(std::cin, line)) { if (!observer.execute(words(line))) { return 2; } } return std::cin.bad() ? 2 : 0; }