Function make_timer_impl

include/concurrencpp/timers/timer_queue.h:58–79

        template<class callable_type>
        timer_ptr make_timer_impl(size_t due_time,
                                  size_t frequency,
                                  std::shared_ptr<concurrencpp::executor> executor,
                                  bool is_oneshot,
                                  callable_type&& callable) {
            assert(static_cast<bool>(executor));

            using decayed_type = typename std::decay_t<callable_type>;

            auto timer_state = std::make_shared<details::timer_state<decayed_type>>(due_time,
                                                                                    frequency,
                                                                                    std::move(executor),
                                                                                    weak_from_this(),
                                                                                    is_oneshot,
                                                                                    std::forward<callable_type>(callable));
            {
                std::unique_lock<std::mutex> lock(m_lock);
                add_timer(lock, timer_state);
            }

            return timer_state;
        }

        void work_loop();