Method process_timers

source/timers/timer_queue.cpp:87–143

            }

            ::time_point process_timers(request_queue& queue) {
                process_request_queue(queue);

                const auto now = high_resolution_clock::now();

                while (true) {
                    if (m_timers.empty()) {
                        break;
                    }

                    timer_set temp_set;

                    auto first_timer_it = m_timers.begin();  // closest deadline
                    auto timer_ptr = *first_timer_it;
                    const auto is_oneshot = timer_ptr->is_oneshot();

                    if (!timer_ptr->expired(now)) {
                        // if this timer is not expired, the next ones are guaranteed not to, as
                        // the set is ordered by deadlines.
                        break;
                    }

                    // we are going to modify the timer, so first we extract it
                    auto timer_node = m_timers.extract(first_timer_it);

                    // we cannot use the naked node_handle according to the standard. it must
                    // be contained somewhere.
                    auto temp_it = temp_set.insert(std::move(timer_node));

                    // we fire it only if it's not cancelled
                    const auto cancelled = timer_ptr->cancelled();
                    if (!cancelled) {
                        (*temp_it)->fire();
                    }

                    if (is_oneshot || cancelled) {
                        m_iterator_mapper.erase(timer_ptr);
                        continue;  // let the timer die inside temp_set
                    }

                    // regular timer, re-insert into the right position
                    timer_node = temp_set.extract(temp_it);
                    auto new_it = m_timers.insert(std::move(timer_node));
                    // AppleClang doesn't have std::unordered_map::contains yet
                    assert(m_iterator_mapper.find(timer_ptr) != m_iterator_mapper.end());
                    m_iterator_mapper[timer_ptr] = new_it;  // update the iterator map, multiset::extract invalidates the
                    // timer
                }

                if (m_timers.empty()) {
                    reset_containers_memory();
                    return now + std::chrono::hours(24);
                }

                // get the closest deadline.
                return (**m_timers.begin()).get_deadline();
            }
        };