Abrufen eines Bezeichners aus dem Timeout std :: future?

Question

Ich habe einen Async-Executor, der Anfragen an einen Server mit einer ID sendet. Der Server führt die Anforderung aus, und der Executor kann das Workitem promise aus demselben ID-Wert in der Antwort identifizieren. Anfragen können eine Zeitüberschreitung verursachen. In diesem Fall möchte ich, dass der Executor die ID dieser Anfrage vollständig löscht. Ich weiß jedoch nicht, wie dieses Versprechen zu verstehen ist, wenn die Zukunft ausläuft und es keine ID vom Server gibt.

Ich poste ein vereinfachtes Beispiel für die Kürze.

struct Executor { 
    std::map<work_id_t, std::promise<Result>> work_items; 
}; 

// run requests asynchronously 
std::future<Result> Executor::post_work(Request r, work_id_t id) { 
    work_items[id] = std::promise<Result>(); 
    do_request(w); 
    return work_items[id].get_future(); 
} 

// called when a requests finishes (the server supplies the id) 
void Executor::work_finished(work_id_t id, Result r) { 
    work_items[id].set_value(r); 
    work_items.erase(id); 
} 

// ... 

Executor e; 
auto ft = e.post_work(Request("foo"));  
auto wait_result = ft.wait_for(timeout_value); 
if (wait_result == std::future_status::timeout) { 
    e.remove_item(???); // what can I pass here? 
} 

Wie kann ich die remove_item Funktion implementieren, wenn ein Timeout passiert? Alternativ, wie kann ich mein Design ändern, um einen ähnlichen Mechanismus zu ermöglichen?

Answer 1

Von der von Ihnen gelieferten Schnittstelle scheint es, dass die work_id_t im Anruf an Executor::post_work verfügbar ist.

Als solches, da der Anrufer die ID im Fall eines Timeout muss nur beide zurückgeben, die Zukunft und die ID von post_work:

Vielleicht ist es in einer Struktur wickeln wie:

struct Work { 
    std::future<Result> ft; 
    work_id_t id; 
}; 

Wenn Sie eine Work Instanz von Executor::post_work zurückkehren, können Sie dann auf die Zukunft warten, und im Falle eines Timeout, verwenden Sie die ID, um den Artikel

Work w = ... 
auto wait_result = w.ft.wait_for(timeout_value); 
if (wait_result == std::future_status::timeout) { 
    e.remove_item(w.id); 
} 

zu entfernen

Im Zusammenhang mit Ihrem Beispiel:

struct Executor { 
    std::map<work_id_t, std::promise<Result>> work_items; 
}; 

struct Work { 
    std::future<Result> ft; 
    work_id_t id; 
}; 

// run requests asynchronously 
Work Executor::post_work(Request r, work_id_t id) { 
    work_items[id] = std::promise<Result>(); 
    do_request(w); 
    return { work_items[id].get_future(), id }; 
} 

// called when a requests finishes (the server supplies the id) 
void Executor::work_finished(work_id_t id, Result r) { 
    work_items[id].set_value(r); 
    work_items.erase(id); 
} 

// ... 

Executor e; 
Work w = e.post_work(Request("foo"));  
auto wait_result = w.ft.wait_for(timeout_value); 
if (wait_result == std::future_status::timeout) { 
    e.remove_item(w.id); 
}