~singpolyma/biboumi

5cca518c2d946144f4fee1b15dcfd3884850dcb1 — Florent Le Coz 9 years ago a63faf6
Timed events can have a name, and can be canceled based on their name
M src/test.cpp => src/test.cpp +11 -0
@@ 83,6 83,17 @@ int main()
  assert(te_manager.execute_expired_events() == 1);
  assert(te_manager.get_timeout() == utils::no_timeout);

  // Test canceling events
  te_manager.add_event(TimedEvent(std::chrono::steady_clock::now() + 100ms, [](){ }, "un"));
  te_manager.add_event(TimedEvent(std::chrono::steady_clock::now() + 200ms, [](){ }, "deux"));
  te_manager.add_event(TimedEvent(std::chrono::steady_clock::now() + 300ms, [](){ }, "deux"));
  assert(te_manager.get_timeout() > 0ms);
  assert(te_manager.size() == 3);
  assert(te_manager.cancel("un") == 1);
  assert(te_manager.size() == 2);
  assert(te_manager.cancel("deux") == 2);
  assert(te_manager.get_timeout() == utils::no_timeout);

  /**
   * Encoding
   */

M src/utils/timed_events.cpp => src/utils/timed_events.cpp +13 -5
@@ 1,20 1,22 @@
#include <utils/timed_events.hpp>

TimedEvent::TimedEvent(std::chrono::steady_clock::time_point&& time_point,
                       std::function<void()> callback):
                       std::function<void()> callback, const std::string& name):
  time_point(std::move(time_point)),
  callback(callback),
  repeat(false),
  repeat_delay(0)
  repeat_delay(0),
  name(name)
{
}

TimedEvent::TimedEvent(std::chrono::milliseconds&& duration,
                       std::function<void()> callback):
                       std::function<void()> callback, const std::string& name):
  time_point(std::chrono::steady_clock::now() + duration),
  callback(callback),
  repeat(true),
  repeat_delay(std::move(duration))
  repeat_delay(std::move(duration)),
  name(name)
{
}



@@ 22,7 24,8 @@ TimedEvent::TimedEvent(TimedEvent&& other):
  time_point(std::move(other.time_point)),
  callback(std::move(other.callback)),
  repeat(other.repeat),
  repeat_delay(std::move(other.repeat_delay))
  repeat_delay(std::move(other.repeat_delay)),
  name(std::move(other.name))
{
}



@@ 52,3 55,8 @@ void TimedEvent::execute()
{
  this->callback();
}

const std::string& TimedEvent::get_name() const
{
  return this->name;
}

M src/utils/timed_events.hpp => src/utils/timed_events.hpp +18 -2
@@ 25,9 25,9 @@ public:
   * An event the occurs only once, at the given time_point
   */
  explicit TimedEvent(std::chrono::steady_clock::time_point&& time_point,
                      std::function<void()> callback);
                      std::function<void()> callback, const std::string& name="");
  explicit TimedEvent(std::chrono::milliseconds&& duration,
                      std::function<void()> callback);
                      std::function<void()> callback, const std::string& name="");

  explicit TimedEvent(TimedEvent&&);
  ~TimedEvent();


@@ 43,6 43,7 @@ public:
   */
  std::chrono::milliseconds get_timeout() const;
  void execute();
  const std::string& get_name() const;

private:
  /**


@@ 62,6 63,12 @@ private:
   * if repeat is true. Otherwise it is ignored.
   */
  const std::chrono::milliseconds repeat_delay;
  /**
   * A name that is used to identify that event. If you want to find your
   * event (for example if you want to cancel it), the name should be
   * unique.
   */
  const std::string name;

  TimedEvent(const TimedEvent&) = delete;
  TimedEvent& operator=(const TimedEvent&) = delete;


@@ 99,6 106,15 @@ public:
   * Returns the number of executed events.
   */
  std::size_t execute_expired_events();
  /**
   * Remove (and thus cancel) all the timed events with the given name.
   * Returns the number of canceled events.
   */
  std::size_t cancel(const std::string& name);
  /**
   * Return the number of managed events.
   */
  std::size_t size() const;

private:
  std::list<TimedEvent> events;

M src/utils/timed_events_manager.cpp => src/utils/timed_events_manager.cpp +20 -0
@@ 53,3 53,23 @@ std::size_t TimedEventsManager::execute_expired_events()
  return count;
}

std::size_t TimedEventsManager::cancel(const std::string& name)
{
  std::size_t res = 0;
  for (auto it = this->events.begin(); it != this->events.end();)
    {
      if (it->get_name() == name)
        {
          it = this->events.erase(it);
          res++;
        }
      else
        ++it;
    }
  return res;
}

std::size_t TimedEventsManager::size() const
{
  return this->events.size();
}