Design: Thread-Safe Queue — mutex, condition_variable, bounded, move semantics

// Thread-Safe Queue — most asked C++ design question
// Encapsulates: mutex, condition_variable, bounded/unbounded queue

template <typename T>
class TSQueue {
    mutable mutex mtx_;
    condition_variable not_empty_;
    condition_variable not_full_;
    deque<T> q_;
    size_t capacity_; // 0 = unbounded

public:
    explicit TSQueue(size_t cap = 0) : capacity_(cap) {}

    // Blocking push — waits if full
    void push(T val) {
        unique_lock<mutex> lk(mtx_);
        not_full_.wait(lk, [this] { return capacity_ == 0 || q_.size() < capacity_; });
        q_.push_back(move(val));
        not_empty_.notify_one();
    }

    // Non-blocking push — returns false if full
    bool try_push(T val) {
        lock_guard<mutex> lk(mtx_);
        if (capacity_ && q_.size() >= capacity_)
            return false;
        q_.push_back(move(val));
        not_empty_.notify_one();
        return true;
    }

    // Blocking pop — waits until element available
    T pop() {
        unique_lock<mutex> lk(mtx_);
        not_empty_.wait(lk, [this] { return !q_.empty(); });
        T val = move(q_.front());
        q_.pop_front();
        not_full_.notify_one();
        return val;
    }

    // Non-blocking pop — returns nullopt if empty
    optional<T> try_pop() {
        lock_guard<mutex> lk(mtx_);
        if (q_.empty())
            return nullopt;
        T val = move(q_.front());
        q_.pop_front();
        not_full_.notify_one();
        return val;
    }

    // Drain — pop all remaining items (for shutdown)
    void drain(vector<T>& out) {
        lock_guard<mutex> lk(mtx_);
        while (!q_.empty()) {
            out.push_back(move(q_.front()));
            q_.pop_front();
        }
    }

    size_t size() const {
        lock_guard<mutex> lk(mtx_);
        return q_.size();
    }
    bool empty() const {
        lock_guard<mutex> lk(mtx_);
        return q_.empty();
    }
};