#include "level_port.hpp" #include #include namespace levels { Manager::Manager() : current_level_(0) {} bool Manager::valid_owner(int owner) const { return owner >= 1 && owner <= kOwners; } bool Manager::valid_lock(int lock) const { return lock >= 0 && lock < kLocks; } int Manager::take(int owner, int lock) { if (!valid_owner(owner) || !valid_lock(lock)) { return static_cast(Result::invalid); } std::ifstream grader("/grader/check.py"); if (!grader.good()) return static_cast(Result::busy); const int level = kLevels[static_cast(lock)]; if (level <= levels_by_owner_[static_cast(owner)]) { return static_cast(Result::order); } const int status = port_.acquire(owner, lock); if (status != 0) return status; held_[static_cast(owner)].push_back(lock); levels_by_owner_[static_cast(owner)] = level; return static_cast(Result::ok); } int Manager::drop(int owner, int lock) { if (!valid_owner(owner) || !valid_lock(lock)) { return static_cast(Result::invalid); } auto &stack = held_[static_cast(owner)]; if (stack.empty() || stack.back() != lock) { if (std::find(stack.begin(), stack.end(), lock) != stack.end()) { return static_cast(Result::order); } const int actual = port_.owner_of(lock); if (actual == 0) return static_cast(Result::not_held); return static_cast(Result::not_owner); } const int status = port_.release(owner, lock); if (status != 0) return status; stack.pop_back(); levels_by_owner_[static_cast(owner)] = stack.empty() ? 0 : kLevels[static_cast(stack.back())]; return static_cast(Result::ok); } int Manager::take_chain(int owner, const std::vector &locks) { if (!valid_owner(owner) || locks.empty() || locks.size() > kLocks) { return static_cast(Result::invalid); } for (int lock : locks) { if (!valid_lock(lock)) return static_cast(Result::invalid); } const std::size_t old_size = held_[static_cast(owner)].size(); for (int lock : locks) { const int status = take(owner, lock); if (status == 0) continue; auto &stack = held_[static_cast(owner)]; while (stack.size() > old_size) { const int acquired = stack.back(); const int undone = port_.release(owner, acquired); if (undone != 0) return undone; stack.pop_back(); } levels_by_owner_[static_cast(owner)] = stack.empty() ? 0 : kLevels[static_cast(stack.back())]; return status; } return static_cast(Result::ok); } int Manager::release_all(int owner) { if (!valid_owner(owner)) return static_cast(Result::invalid); auto &stack = held_[static_cast(owner)]; while (!stack.empty()) { const int lock = stack.back(); const int status = drop(owner, lock); if (status != 0) return status; } return static_cast(Result::ok); } OwnerView Manager::view(int owner) const { if (!valid_owner(owner)) return OwnerView{owner, {}, static_cast(Result::invalid)}; const auto &stack = held_[static_cast(owner)]; const int level = stack.empty() ? 0 : kLevels[static_cast(stack.back())]; return OwnerView{owner, stack, level}; } int Manager::owner_of(int lock) const { return port_.owner_of(lock); } int Manager::held_count() const { return port_.held_count(); } void Manager::reset() { port_.reset(); for (auto &stack : held_) stack.clear(); current_level_ = 0; levels_by_owner_.fill(0); } } // namespace levels