completions.hpp

#pragma once
 
#include "base.hpp"
 
#include <utility>
#include <vector>
 
namespace NNet {
namespace NDetail {

struct TOperationState {
    TOperationState() = default;
    TOperationState(const TOperationState&) = delete;
    TOperationState& operator=(const TOperationState&) = delete;
 
    THandle Handle; 
    int Result = 0; 
    unsigned Index = 0; 
};

class TCompletions {
public:
    void Collect(TOperationState* op, int result) {
        op->Result = result;
        Add(Ready_, op);
    }

    void Reap(TOperationState* op, int result) {
        op->Result = result;
        Add(Reaped_, op);
    }

    bool Drop(TOperationState& op) {
        // The lists hold only completions not delivered yet, so an entry that
        // points to op is its completion, whatever Index held before.
        return Remove(Ready_, op) || Remove(Reaped_, op);
    }

    bool Carry() {
        size_t size = 0;
        for (auto* op : Ready_) {
            if (op) {
                op->Index = static_cast<unsigned>(size);
                Ready_[size++] = op;
            }
        }
        Ready_.resize(size);
        for (auto* op : Reaped_) {
            if (op) {
                Add(Ready_, op);
            }
        }
        Reaped_.clear();
        return !Ready_.empty();
    }

    void Wakeup() {
        for (size_t i = 0; i < Ready_.size(); i++) {
            // Taken out before resuming: the coroutine may post its next operation
            // at the same address, and Drop() must not find this entry for it.
            if (auto* op = std::exchange(Ready_[i], nullptr)) {
                std::exchange(op->Handle, {}).resume();
            }
        }
        Ready_.clear();
    }
 
private:
    static void Add(std::vector<TOperationState*>& list, TOperationState* op) {
        op->Index = static_cast<unsigned>(list.size());
        list.push_back(op);
    }
 
    static bool Remove(std::vector<TOperationState*>& list, TOperationState& op) {
        if (op.Index < list.size() && list[op.Index] == &op) {
            list[op.Index] = nullptr;
            return true;
        }
        return false;
    }
 
    std::vector<TOperationState*> Ready_;
    std::vector<TOperationState*> Reaped_;
};
 
} // namespace NDetail
} // namespace NNet