13 files changed, 48 insertions(+), 41 deletions(-)

M module-apps/application-alarm-clock/models/AlarmsRepository.cpp
M module-db/Interface/AlarmEventRecord.cpp
M module-db/Tables/AlarmEventsTable.cpp
M module-db/Tables/AlarmEventsTable.hpp
M module-db/Tables/Table.hpp
M module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.cpp
M module-db/queries/alarm_events/QueryAlarmEventsGetBetweenDates.hpp
M module-db/tests/AlarmEventRecord_tests.cpp
M module-services/service-time/AlarmMessageHandler.cpp
M module-services/service-time/AlarmOperations.cpp
M module-services/service-time/AlarmOperations.hpp
M module-services/service-time/AlarmRepository.hpp
M module-services/service-time/include/service-time/AlarmMessage.hpp

@@ 28,7 28,7 @@ namespace app::alarmClock
                 return false;
             }
             if (callback) {
-                callback(result->alarms, result->alarms.size());
+                callback(result->alarms, result->count);
             }
             return true;
         };

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "AlarmEventRecord.hpp"


@@ 107,11 107,11 @@ std::unique_ptr<db::query::alarmEvents::GetResult> AlarmEventRecordInterface::ru
 std::unique_ptr<db::query::alarmEvents::GetBetweenDatesResult> AlarmEventRecordInterface::runQueryImplGetBetweenDates(
     std::shared_ptr<db::query::alarmEvents::GetBetweenDates> query)
 {
-    const auto alarmEventsRows =
+    const auto [alarmEventsRows, count] =
         eventsDB->alarmEvents.getBetweenDates(query->start, query->end, query->offset, query->limit);
     const auto recordVector = generateRecordsVector(alarmEventsRows);
 
-    auto response = std::make_unique<db::query::alarmEvents::GetBetweenDatesResult>(recordVector);
+    auto response = std::make_unique<db::query::alarmEvents::GetBetweenDatesResult>(recordVector, count);
     response->setRequestQuery(query);
 
     return response;

@@ 180,10 180,10 @@ std::vector<AlarmEventsTableRow> AlarmEventsTable::getLimitOffsetByField(uint32_
     return retQueryUnpack(std::move(retQuery));
 }
 
-std::vector<AlarmEventsTableRow> AlarmEventsTable::getBetweenDates(TimePoint startDate,
-                                                                   TimePoint endDate,
-                                                                   uint32_t offset,
-                                                                   uint32_t limit)
+std::pair<std::vector<AlarmEventsTableRow>, std::uint32_t> AlarmEventsTable::getBetweenDates(TimePoint startDate,
+                                                                                             TimePoint endDate,
+                                                                                             std::uint32_t offset,
+                                                                                             std::uint32_t limit)
 {
     auto retQuery = db->query("SELECT * FROM events e "
                               "JOIN alarm_events ae ON ae.event_id = e._id "


@@ 194,7 194,7 @@ std::vector<AlarmEventsTableRow> AlarmEventsTable::getBetweenDates(TimePoint sta
                               limit,
                               offset);
 
-    return retQueryUnpack(std::move(retQuery));
+    return {retQueryUnpack(std::move(retQuery)), count()};
 }
 
 std::vector<AlarmEventsTableRow> AlarmEventsTable::getRecurringBetweenDates(TimePoint startDate,

@@ 63,8 63,8 @@ class AlarmEventsTable : public Table<AlarmEventsTableRow, AlarmEventsTableField
     auto getLimitOffset(uint32_t offset, uint32_t limit) -> std::vector<AlarmEventsTableRow> override;
     auto getLimitOffsetByField(uint32_t offset, uint32_t limit, AlarmEventsTableFields field, const char *str)
         -> std::vector<AlarmEventsTableRow> override;
-    auto getBetweenDates(TimePoint startDate, TimePoint endDate, uint32_t offset, uint32_t limit)
-        -> std::vector<AlarmEventsTableRow>;
+    auto getBetweenDates(TimePoint startDate, TimePoint endDate, std::uint32_t offset, std::uint32_t limit)
+        -> std::pair<std::vector<AlarmEventsTableRow>, std::uint32_t>;
     auto getRecurringBetweenDates(TimePoint startDate, TimePoint endDate, uint32_t offset, uint32_t limit)
         -> std::vector<AlarmEventsTableRow>;
     auto getNext(TimePoint start, uint32_t offset, uint32_t limit) -> std::vector<AlarmEventsTableRow>;

@@ 3,6 3,7 @@
 
 #pragma once
 
+#include "Record.hpp"
 #include <Database/Database.hpp>
 
 #include <functional>


@@ 49,6 50,7 @@ template <typename T, typename F> class Table
         }
 
         std::vector<T> outVector;
+        outVector.reserve(retQuery->getRowCount());
 
         do {
             outVector.push_back(createTableRow(*retQuery));

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #include "QueryAlarmEventsGetBetweenDates.hpp"


@@ 7,7 7,7 @@
 
 namespace db::query::alarmEvents
 {
-    GetBetweenDates::GetBetweenDates(TimePoint start, TimePoint end, uint32_t offset, uint32_t limit)
+    GetBetweenDates::GetBetweenDates(TimePoint start, TimePoint end, std::uint32_t offset, std::uint32_t limit)
         : Query(Query::Type::Read), start(start), end(end), offset(offset), limit(limit)
     {}
 


@@ 16,12 16,13 @@ namespace db::query::alarmEvents
         return std::string{"GetBetweenDates"};
     }
 
-    GetBetweenDatesResult::GetBetweenDatesResult(std::vector<AlarmEventRecord> records) : records(std::move(records))
+    GetBetweenDatesResult::GetBetweenDatesResult(std::vector<AlarmEventRecord> records, std::uint32_t count)
+        : records(std::move(records)), count(count)
     {}
 
-    auto GetBetweenDatesResult::getResult() const -> std::vector<AlarmEventRecord>
+    auto GetBetweenDatesResult::getResult() const -> std::pair<std::vector<AlarmEventRecord>, std::uint32_t>
     {
-        return records;
+        return {records, count};
     }
 
     auto GetBetweenDatesResult::debugInfo() const -> std::string

@@ 1,4 1,4 @@
-// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
+// Copyright (c) 2017-2021, Mudita Sp. z.o.o. All rights reserved.
 // For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md
 
 #pragma once


@@ 14,23 14,23 @@ namespace db::query::alarmEvents
     class GetBetweenDates : public Query
     {
       public:
-        GetBetweenDates(TimePoint start, TimePoint end, uint32_t offset, uint32_t limit);
+        GetBetweenDates(TimePoint start, TimePoint end, std::uint32_t offset, std::uint32_t limit);
         [[nodiscard]] auto debugInfo() const -> std::string override;
 
         const TimePoint start = TIME_POINT_INVALID;
         const TimePoint end   = TIME_POINT_INVALID;
-        const uint32_t offset = 0;
-        const uint32_t limit  = 0;
+        const std::uint32_t offset = 0;
+        const std::uint32_t limit  = 0;
     };
 
     class GetBetweenDatesResult : public QueryResult
     {
         const std::vector<AlarmEventRecord> records;
+        const std::uint32_t count = 0;
 
       public:
-        explicit GetBetweenDatesResult(std::vector<AlarmEventRecord> records);
-        [[nodiscard]] auto getResult() const -> std::vector<AlarmEventRecord>;
-
+        explicit GetBetweenDatesResult(std::vector<AlarmEventRecord> records, std::uint32_t count);
+        [[nodiscard]] auto getResult() const -> std::pair<std::vector<AlarmEventRecord>, std::uint32_t>;
         [[nodiscard]] auto debugInfo() const -> std::string override;
     };
 

@@ 387,19 387,21 @@ TEST_CASE("AlarmEventRecord tests")
 
         auto retAlarmEvents = getBetweenDatesQuery(
             TimePointFromString("2020-01-01 00:00:00"), TimePointFromString("2020-02-01 00:00:00"), 0, 10);
-        REQUIRE(retAlarmEvents.size() == 1);
-        REQUIRE(retAlarmEvents[0].ID == 1);
+        REQUIRE(retAlarmEvents.first.size() == 1);
+        REQUIRE(retAlarmEvents.first[0].ID == 1);
 
         retAlarmEvents = getBetweenDatesQuery(
             TimePointFromString("2020-05-01 00:00:00"), TimePointFromString("2020-10-01 00:00:00"), 0, 10);
-        REQUIRE(retAlarmEvents.size() == 2);
-        REQUIRE(retAlarmEvents[0].ID == 2);
-        REQUIRE(retAlarmEvents[1].ID == 3);
+        REQUIRE(retAlarmEvents.first.size() == 2);
+        REQUIRE(retAlarmEvents.first[0].ID == 2);
+        REQUIRE(retAlarmEvents.first[1].ID == 3);
 
         retAlarmEvents = getBetweenDatesQuery(
             TimePointFromString("2020-05-01 00:00:00"), TimePointFromString("2020-10-01 00:00:00"), 1, 10);
-        REQUIRE(retAlarmEvents.size() == 1);
-        REQUIRE(retAlarmEvents[0].ID == 3);
+        REQUIRE(retAlarmEvents.first.size() == 1);
+        REQUIRE(retAlarmEvents.first[0].ID == 3);
+
+        REQUIRE(retAlarmEvents.second == 3);
     }
 
     SECTION("Get Next")


@@ 446,8 448,10 @@ TEST_CASE("AlarmEventRecord tests")
                  testEnabled,
                  testSnoozeDuration);
 
-        retAlarmEvents = getBetweenDatesQuery(
-            TimePointFromString("2020-05-01 00:00:00"), TimePointFromString("2020-10-01 00:00:00"), 1, 10);
+        retAlarmEvents =
+            getBetweenDatesQuery(
+                TimePointFromString("2020-05-01 00:00:00"), TimePointFromString("2020-10-01 00:00:00"), 1, 10)
+                .first;
         retAlarmEvents = getNextQuery(TimePointFromString("2020-01-01 00:00:00"), 0, 10);
         REQUIRE(retAlarmEvents.size() == 2);
         REQUIRE((((retAlarmEvents[0].ID == 3) && (retAlarmEvents[1].ID == 4)) ||

@@ 57,11 57,11 @@ namespace alarms
     {
         return handleWithCallback<AlarmsGetInRangeRequestMessage,
                                   AlarmsGetInRangeResponseMessage,
-                                  std::vector<AlarmEventRecord>>(
+                                  std::pair<std::vector<AlarmEventRecord>, std::uint32_t>>(
             request,
             [&](AlarmsGetInRangeRequestMessage *request, IAlarmOperations::OnGetAlarmsInRangeProcessed callback) {
                 alarmOperations->getAlarmsInRange(
-                    request->start, request->end, request->offset, request->limit, callback);
+                    request->start, request->end, request->offset, request->limit, std::move(callback));
             });
     }
 

@@ 72,9 72,7 @@ namespace alarms
     void AlarmOperations::getAlarmsInRange(
         TimePoint start, TimePoint end, std::uint32_t offset, std::uint32_t limit, OnGetAlarmsInRangeProcessed callback)
     {
-        OnGetAlarmEventsInRangeCallback repoCallback = [callback](std::vector<AlarmEventRecord> records) {
-            callback(records);
-        };
+        OnGetAlarmEventsInRangeCallback repoCallback = [callback](auto vals) { callback(std::move(vals)); };
         alarmEventsRepo->getAlarmEventsInRange(start, end, offset, limit, repoCallback);
     }
 

@@ 16,7 16,7 @@ namespace alarms
     {
       public:
         using OnGetAlarmProcessed         = std::function<void(AlarmEventRecord)>;
-        using OnGetAlarmsInRangeProcessed = std::function<void(std::vector<AlarmEventRecord>)>;
+        using OnGetAlarmsInRangeProcessed = std::function<void(std::pair<std::vector<AlarmEventRecord>, uint32_t>)>;
         using OnAddAlarmProcessed         = std::function<void(bool)>;
         using OnUpdateAlarmProcessed      = std::function<void(bool)>;
         using OnRemoveAlarmProcessed      = std::function<void(bool)>;

@@ 21,7 21,8 @@ namespace alarms
 {
     using OnGetAlarmEventCallback          = std::function<void(AlarmEventRecord)>;
     using OnGetAlarmEventsCallback         = std::function<void(std::vector<AlarmEventRecord>)>;
-    using OnGetAlarmEventsInRangeCallback  = std::function<void(std::vector<AlarmEventRecord>)>;
+    using OnGetAlarmEventsInRangeCallback =
+        std::function<void(std::pair<std::vector<AlarmEventRecord>, std::uint32_t>)>;
     using OnAddAlarmEventCallback          = std::function<void(bool)>;
     using OnUpdateAlarmEventCallback       = std::function<void(bool)>;
     using OnRemoveAlarmEventCallback       = std::function<void(bool)>;

@@ 98,9 98,10 @@ namespace alarms
     class AlarmsGetInRangeResponseMessage : public AlarmResponse
     {
       public:
-        AlarmsGetInRangeResponseMessage(std::vector<AlarmEventRecord> alarms = std::vector<AlarmEventRecord>())
-            : alarms(alarms){};
+        explicit AlarmsGetInRangeResponseMessage(std::pair<std::vector<AlarmEventRecord>, std::uint32_t> p)
+            : alarms(std::move(p.first)), count(p.second){};
         std::vector<AlarmEventRecord> alarms;
+        const std::uint32_t count = 0;
     };
 
     class AlarmGetNextSingleEventsRequestMessage : public AlarmMessage