add the new Alarm class as an argument to the alarm queue class

1 files changed, 133 insertions, 93 deletions

diff --git a/src/alarm-queue-simple.cpp b/src/alarm-queue-simple.cpp
index f45e61a..db0fd21 100644
--- a/src/alarm-queue-simple.cpp
+++ b/src/alarm-queue-simple.cpp
@@ -20,134 +20,174 @@
 #include <datetime/alarm-queue-simple.h>
 
 #include <cmath>
+#include <set>
 
 namespace unity {
 namespace indicator {
 namespace datetime {
 
 /***
-****  Public API
+****
 ***/
 
-SimpleAlarmQueue::SimpleAlarmQueue(const std::shared_ptr<Clock>& clock,
-                                   const std::shared_ptr<Planner>& planner,
-                                   const std::shared_ptr<WakeupTimer>& timer):
-    m_clock(clock),
-    m_planner(planner),
-    m_timer(timer),
-    m_datetime(clock->localtime())
+class SimpleAlarmQueue::Impl
 {
-    m_planner->appointments().changed().connect([this](const std::vector<Appointment>&){
-        g_debug("AlarmQueue %p calling requeue() due to appointments changed", this);
-        requeue();
-    });
-
-    m_clock->minute_changed.connect([=]{
-        const auto now = m_clock->localtime();
-        constexpr auto skew_threshold_usec = int64_t{90} * G_USEC_PER_SEC;
-        const bool clock_jumped = std::abs(now - m_datetime) > skew_threshold_usec;
-        m_datetime = now;
-        if (clock_jumped) {
-            g_debug("AlarmQueue %p calling requeue() due to clock skew", this);
+public:
+
+    Impl(const std::shared_ptr<Clock>& clock,
+         const std::shared_ptr<Planner>& planner,
+         const std::shared_ptr<WakeupTimer>& timer):
+      m_clock{clock},
+      m_planner{planner},
+      m_timer{timer},
+      m_datetime{clock->localtime()}
+    {
+        m_planner->appointments().changed().connect([this](const std::vector<Appointment>&){
+            g_debug("AlarmQueue %p calling requeue() due to appointments changed", this);
             requeue();
-        }
-    });
+        });
+
+        m_clock->minute_changed.connect([=]{
+            const auto now = m_clock->localtime();
+            constexpr auto skew_threshold_usec = int64_t{90} * G_USEC_PER_SEC;
+            const bool clock_jumped = std::abs(now - m_datetime) > skew_threshold_usec;
+            m_datetime = now;
+            if (clock_jumped) {
+                g_debug("AlarmQueue %p calling requeue() due to clock skew", this);
+                requeue();
+            }
+        });
+
+        m_timer->timeout().connect([this](){
+            g_debug("AlarmQueue %p calling requeue() due to timeout", this);
+            requeue();
+        });
 
-    m_timer->timeout().connect([this](){
-        g_debug("AlarmQueue %p calling requeue() due to timeout", this);
         requeue();
-    });
-
-    requeue();
-}
+    }
 
-SimpleAlarmQueue::~SimpleAlarmQueue()
-{
-}
+    ~Impl()
+    {
+    }
 
-core::Signal<const Appointment&>& SimpleAlarmQueue::alarm_reached()
-{
-    return m_alarm_reached;
-}
+    core::Signal<const Appointment&, const Alarm&>& alarm_reached()
+    {
+        return m_alarm_reached;
+    }
 
-/***
-****
-***/
+private:
 
-void SimpleAlarmQueue::requeue()
-{
-    // kick any current alarms
-    for (auto current : find_current_alarms())
+    void requeue()
     {
-        const std::pair<std::string,DateTime> trig {current.uid, current.begin};
-        m_triggered.insert(trig);
-        m_alarm_reached(current);
+        // kick any current alarms
+        for (const auto& appointment : m_planner->appointments().get())
+        {
+            Alarm alarm;
+            if (appointment_get_current_alarm(appointment, alarm))
+            {
+                m_triggered.insert(std::make_pair(appointment.uid, alarm.time));
+                m_alarm_reached(appointment, alarm);
+            }
+        }
+
+        // idle until the next alarm
+        Alarm next;
+        if (find_next_alarm(next))
+        {
+            g_debug ("setting timer to wake up for next appointment '%s' at %s", 
+                     next.text.c_str(),
+                     next.time.format("%F %T").c_str());
+
+            m_timer->set_wakeup_time(next.time);
+        }
     }
 
-    // idle until the next alarm
-    Appointment next;
-    if (find_next_alarm(next))
+    // find the next alarm that will kick now or in the future
+    bool find_next_alarm(Alarm& setme) const
     {
-        g_debug ("setting timer to wake up for next appointment '%s' at %s", 
-                 next.summary.c_str(),
-                 next.begin.format("%F %T").c_str());
+        bool found = false;
+        Alarm best;
+        const auto now = m_clock->localtime();
+        const auto beginning_of_minute = now.start_of_minute();
 
-        m_timer->set_wakeup_time(next.begin);
-    }
-}
+        const auto appointments = m_planner->appointments().get();
+        g_debug ("planner has %zu appointments in it", (size_t)appointments.size());
 
-// find the next alarm that will kick now or in the future
-bool SimpleAlarmQueue::find_next_alarm(Appointment& setme) const
-{
-    bool found = false;
-    Appointment tmp;
-    const auto now = m_clock->localtime();
-    const auto beginning_of_minute = now.start_of_minute();
+        for(const auto& appointment : appointments)
+        {
+            for(const auto& alarm : appointment.alarms)
+            {
+                const std::pair<std::string,DateTime> trig{appointment.uid, alarm.time};
+                if (m_triggered.count(trig))
+                    continue;
 
-    const auto appointments = m_planner->appointments().get();
-    g_debug ("planner has %zu appointments in it", (size_t)appointments.size());
+                if (alarm.time < beginning_of_minute) // has this one already passed?
+                    continue;
 
-    for(const auto& walk : appointments)
-    {
-        const std::pair<std::string,DateTime> trig {walk.uid, walk.begin};
-        if (m_triggered.count(trig))
-            continue;
+                if (found && (best.time < alarm.time)) // do we already have a better match?
+                    continue;
 
-        if (walk.begin < beginning_of_minute) // has this one already passed?
-            continue;
+                best = alarm;
+                found = true;
+            }
+        }
 
-        if (found && (tmp.begin < walk.begin)) // do we already have a better match?
-            continue;
+        if (found)
+          setme = best;
 
-        tmp = walk;
-        found = true;
+        return found;
     }
 
-    if (found)
-      setme = tmp;
 
-    return found;
-}
+    bool appointment_get_current_alarm(const Appointment& appointment, Alarm& setme) const
+    {
+        const auto now = m_clock->localtime();
 
-// find the alarm(s) that should kick right now
-std::vector<Appointment> SimpleAlarmQueue::find_current_alarms() const
-{
-    std::vector<Appointment> appointments;
+        for (const auto& alarm : appointment.alarms)
+        {
+            const auto trig = std::make_pair(appointment.uid, alarm.time);
+            if (m_triggered.count(trig)) // did we already use this one?
+                continue;
+
+            if (DateTime::is_same_minute(now, alarm.time))
+            {
+                setme = alarm;
+                return true;
+            }
+        }
 
-    const auto now = m_clock->localtime();
+        return false;
+    }
 
-    for(const auto& walk : m_planner->appointments().get())
-    {
-        const std::pair<std::string,DateTime> trig {walk.uid, walk.begin};
-        if (m_triggered.count(trig)) // did we already use this one?
-            continue;
-        if (!DateTime::is_same_minute(now, walk.begin))
-            continue;
 
-        appointments.push_back(walk);
-    }
+    std::set<std::pair<std::string,DateTime>> m_triggered;
+    const std::shared_ptr<Clock> m_clock;
+    const std::shared_ptr<Planner> m_planner;
+    const std::shared_ptr<WakeupTimer> m_timer;
+    core::Signal<const Appointment&, const Alarm&> m_alarm_reached;
+    DateTime m_datetime;
+};
+
+/***
+****  Public API
+***/
+
 
-    return appointments;
+SimpleAlarmQueue::SimpleAlarmQueue(const std::shared_ptr<Clock>& clock,
+                                   const std::shared_ptr<Planner>& planner,
+                                   const std::shared_ptr<WakeupTimer>& timer):
+    impl{new Impl{clock, planner, timer}}
+{
+}
+
+SimpleAlarmQueue::~SimpleAlarmQueue()
+{
+}
+
+core::Signal<const Appointment&, const Alarm&>&
+SimpleAlarmQueue::alarm_reached()
+{
+    return impl->alarm_reached();
 }
 
 /***