waybar/include/util/chrono.hpp

#pragma once

#include <chrono>
#include <ctime>
#include <functional>
#include <condition_variable>
#include <thread>

namespace waybar::chrono {

    using namespace std::chrono;

    using clock = std::chrono::system_clock;
    using duration = clock::duration;
    using time_point = std::chrono::time_point<clock, duration>;

    inline struct timespec to_timespec(time_point t) noexcept
    {
      long secs = duration_cast<seconds>(t.time_since_epoch()).count();
      long nsc = duration_cast<nanoseconds>(t.time_since_epoch() % seconds(1)).count();
      return {secs, nsc};
    }

    inline time_point to_time_point(struct timespec t) noexcept
    {
      return time_point(duration_cast<duration>(seconds(t.tv_sec) + nanoseconds(t.tv_nsec)));
    }

}

namespace waybar::util {

  struct SleeperThread {
    SleeperThread() = default;

    SleeperThread(std::function<void()> func)
      : thread{[this, func] {
          do {
            func();
          } while (do_run);
        }}
    {
      defined = true;
    }

    SleeperThread& operator=(std::function<void()> func)
    {
      thread = std::thread([this, func] {
        do {
          func();
        } while (do_run);
      });
      defined = true;
      return *this;
    }


    auto sleep_for(chrono::duration dur)
    {
      auto lock = std::unique_lock(mutex);
      return condvar.wait_for(lock, dur);
    }

    auto sleep_until(chrono::time_point time)
    {
      auto lock = std::unique_lock(mutex);
      return condvar.wait_until(lock, time);
    }

    auto wake_up()
    {
      condvar.notify_all();
    }

    ~SleeperThread()
    {
      do_run = false;
      if (defined) {
        condvar.notify_all();
        thread.join();
      }
    }

  private:
    std::thread thread;
    std::condition_variable condvar;
    std::mutex mutex;
    bool defined = false;
    bool do_run = true;
  };

}