[SDK 866] Event class move to seprate file (#79)

* Event class move to seprate file

* Update CHANGELOG.md

Co-authored-by: ArtursKadikis <[email protected]>

Author: ZahidZafar

CHANGELOG.md

@@ -1,3 +1,6 @@
+22.06.0
+* !! Major breaking change !! We are extracting the 'Event' class out of the 'Countly' class which will change how that class can be referenced.'Countly::Event' will not work, you will have to use 'cly::Event' instead.
+
 22.02.0
 * Added 10-second time-outs for all windows HTTP transactions.
 * Added ability to record views.

examples/example_integration.cpp

@@ -10,6 +10,7 @@
 #endif
 
 using namespace std;
+using namespace cly;
 
 void printLog(Countly::LogLevel level, const string &msg) {
   string lvl = "[DEBUG]";
@@ -73,7 +74,7 @@ int main() {
       ct.RecordEvent("Event with count and sum", 644, 13.3);
       break;
     case 3: {
-      Countly::Event event("Event with sum, count, duration", 1, 10, 60.5);
+      Event event("Event with sum, count, duration", 1, 10, 60.5);
       ct.addEvent(event);
       break;
     }

include/countly.hpp

@@ -21,6 +21,7 @@
 #ifdef _WIN32
 #undef ERROR
 #endif
+#include "countly/event.hpp"
 #include "countly/logger_module.hpp"
 #include "countly/views_module.hpp"
 
@@ -29,7 +30,6 @@ class Countly : public cly::CountlyDelegates {
   Countly();
 
   ~Countly();
-
   static Countly &getInstance();
 
   // Do not implicitly generate the copy constructor, this is a singleton.
@@ -102,9 +102,7 @@ class Countly : public cly::CountlyDelegates {
 
   void setUpdateInterval(size_t milliseconds);
 
-  class Event;
-
-  void addEvent(const Event &event);
+  void addEvent(const cly::Event &event);
 
   void setMaxEvents(size_t value);
 
@@ -138,33 +136,6 @@ class Countly : public cly::CountlyDelegates {
   void setDatabasePath(const std::string &path);
 #endif
 
-  class Event {
-  public:
-    Event(const std::string &key, size_t count = 1);
-    Event(const std::string &key, size_t count, double sum);
-    Event(const std::string &key, size_t count, double sum, double duration);
-
-    void setTimestamp();
-
-    void startTimer();
-    void stopTimer();
-
-    template <typename T> void addSegmentation(const std::string &key, T value) {
-      if (object.find("segmentation") == object.end()) {
-        object["segmentation"] = nlohmann::json::object();
-      }
-
-      object["segmentation"][key] = value;
-    }
-
-    std::string serialize() const;
-
-  private:
-    nlohmann::json object;
-    bool timer_running;
-    std::chrono::system_clock::time_point timestamp;
-  };
-
   void SetPath(const std::string &path) {
 #ifdef COUNTLY_USE_SQLITE
     setDatabasePath(path);
@@ -187,12 +158,12 @@ class Countly : public cly::CountlyDelegates {
 
   inline cly::ViewsModule &views() const { return *views_module.get(); }
 
-  void RecordEvent(const std::string &key, int count) override { addEvent(Event(key, count)); }
+  void RecordEvent(const std::string &key, int count) override { addEvent(cly::Event(key, count)); }
 
-  void RecordEvent(const std::string &key, int count, double sum) override { addEvent(Event(key, count, sum)); }
+  void RecordEvent(const std::string &key, int count, double sum) override { addEvent(cly::Event(key, count, sum)); }
 
   void RecordEvent(const std::string &key, const std::map<std::string, std::string> &segmentation, int count) override {
-    Event event(key, count);
+    cly::Event event(key, count);
 
     for (auto key_value : segmentation) {
       event.addSegmentation(key_value.first, key_value.second);
@@ -202,7 +173,7 @@ class Countly : public cly::CountlyDelegates {
   }
 
   void RecordEvent(const std::string &key, const std::map<std::string, std::string> &segmentation, int count, double sum) override {
-    Event event(key, count, sum);
+    cly::Event event(key, count, sum);
 
     for (auto key_value : segmentation) {
       event.addSegmentation(key_value.first, key_value.second);
@@ -212,7 +183,7 @@ class Countly : public cly::CountlyDelegates {
   }
 
   void RecordEvent(const std::string &key, const std::map<std::string, std::string> &segmentation, int count, double sum, double duration) override {
-    Event event(key, count, sum, duration);
+    cly::Event event(key, count, sum, duration);
 
     for (auto key_value : segmentation) {
       event.addSegmentation(key_value.first, key_value.second);

include/countly/event.hpp

@@ -0,0 +1,36 @@
+#ifndef EVENT_HPP_
+#define EVENT_HPP_
+#include "nlohmann/json.hpp"
+#include <chrono>
+#include <string>
+
+namespace cly {
+
+class Event {
+public:
+  Event(const std::string &key, size_t count = 1);
+  Event(const std::string &key, size_t count, double sum);
+  Event(const std::string &key, size_t count, double sum, double duration);
+
+  void setTimestamp();
+
+  void startTimer();
+  void stopTimer();
+
+  template <typename T> void addSegmentation(const std::string &key, T value) {
+    if (object.find("segmentation") == object.end()) {
+      object["segmentation"] = nlohmann::json::object();
+    }
+
+    object["segmentation"][key] = value;
+  }
+
+  std::string serialize() const;
+
+private:
+  nlohmann::json object;
+  bool timer_running;
+  std::chrono::system_clock::time_point timestamp;
+};
+} // namespace cly
+#endif

src/countly.cpp

@@ -391,7 +391,7 @@ void Countly::setUpdateInterval(size_t milliseconds) {
   mutex.unlock();
 }
 
-void Countly::addEvent(const Event &event) {
+void Countly::addEvent(const cly::Event &event) {
   mutex.lock();
 #ifndef COUNTLY_USE_SQLITE
   if (event_queue.size() == max_events) {

src/event.cpp

@@ -1,39 +1,41 @@
-#include "countly.hpp"
+#include "countly/event.hpp"
 
-Countly::Event::Event(const std::string &key, size_t count) : object({}), timer_running(false) {
+namespace cly {
+Event::Event(const std::string &key, size_t count) : object({}), timer_running(false) {
   object["key"] = key;
   object["count"] = count;
 }
 
-Countly::Event::Event(const std::string &key, size_t count, double sum) : object({}), timer_running(false) {
+Event::Event(const std::string &key, size_t count, double sum) : object({}), timer_running(false) {
   object["key"] = key;
   object["count"] = count;
   object["sum"] = sum;
 }
 
-Countly::Event::Event(const std::string &key, size_t count, double sum, double duration) : object({}), timer_running(false) {
+Event::Event(const std::string &key, size_t count, double sum, double duration) : object({}), timer_running(false) {
   object["key"] = key;
   object["count"] = count;
   object["sum"] = sum;
   object["dur"] = duration;
 }
 
-void Countly::Event::setTimestamp() {
-  timestamp = Countly::getTimestamp();
+void Event::setTimestamp() {
+  timestamp = std::chrono::system_clock::now();
   object["timestamp"] = std::chrono::duration_cast<std::chrono::seconds>(timestamp.time_since_epoch()).count();
 }
 
-void Countly::Event::startTimer() {
+void Event::startTimer() {
   setTimestamp();
   timer_running = true;
 }
 
-void Countly::Event::stopTimer() {
+void Event::stopTimer() {
   if (timer_running) {
-    auto now = Countly::getTimestamp();
+    auto now = std::chrono::system_clock::now();
     object["dur"] = std::chrono::duration_cast<std::chrono::seconds>(now - timestamp).count();
     timer_running = false;
   }
 }
 
-std::string Countly::Event::serialize() const { return object.dump(); }
+std::string Event::serialize() const { return object.dump(); }
+} // namespace cly

tests/event.cpp

@@ -4,63 +4,63 @@
 TEST_CASE("events are serialized correctly") {
   SUBCASE("without segmentation") {
     SUBCASE("without sum") {
-      Countly::Event event("win", 1);
+      cly::Event event("win", 1);
       CHECK(event.serialize() == "{\"count\":1,\"key\":\"win\"}");
     }
 
     SUBCASE("with sum") {
-      Countly::Event event("buy", 2, 9.99);
+      cly::Event event("buy", 2, 9.99);
       CHECK(event.serialize() == "{\"count\":2,\"key\":\"buy\",\"sum\":9.99}");
     }
   }
 
   SUBCASE("with segmentation") {
     SUBCASE("with signed integer") {
-      Countly::Event event("lose", 3);
+      cly::Event event("lose", 3);
       event.addSegmentation("points", -144);
       CHECK(event.serialize() == "{\"count\":3,\"key\":\"lose\",\"segmentation\":{\"points\":-144}}");
     }
 
     SUBCASE("with unsigned integer") {
-      Countly::Event event("win", 1);
+      cly::Event event("win", 1);
       event.addSegmentation("points", 232U);
       CHECK(event.serialize() == "{\"count\":1,\"key\":\"win\",\"segmentation\":{\"points\":232}}");
     }
 
     SUBCASE("with boolean") {
-      Countly::Event event("win", 1);
+      cly::Event event("win", 1);
       event.addSegmentation("alive", true);
       CHECK(event.serialize() == "{\"count\":1,\"key\":\"win\",\"segmentation\":{\"alive\":true}}");
     }
 
     SUBCASE("with string") {
-      Countly::Event event("message", 1);
+      cly::Event event("message", 1);
       event.addSegmentation("sender", "TheLegend27");
       CHECK(event.serialize() == "{\"count\":1,\"key\":\"message\",\"segmentation\":{\"sender\":\"TheLegend27\"}}");
     }
 
     SUBCASE("with multiple values") {
-      Countly::Event event("buy", 5);
+      cly::Event event("buy", 5);
       event.addSegmentation("quantity", 27);
       event.addSegmentation("searchQuery", "cheap cheese");
       CHECK(event.serialize() == "{\"count\":5,\"key\":\"buy\",\"segmentation\":{\"quantity\":27,\"searchQuery\":\"cheap cheese\"}}");
     }
 
     SUBCASE("with changing values") {
-      Countly::Event event("lose", 3);
+      cly::Event event("lose", 3);
       event.addSegmentation("points", -144);
       event.addSegmentation("points", 2000);
       CHECK(event.serialize() == "{\"count\":3,\"key\":\"lose\",\"segmentation\":{\"points\":2000}}");
     }
 
     SUBCASE("with count, sum, duration and segmentation") {
-      Countly::Event event("lose", 3, 10, 100);
+      cly::Event event("lose", 3, 10, 100);
       event.addSegmentation("points", 2000);
       CHECK(event.serialize() == "{\"count\":3,\"dur\":100.0,\"key\":\"lose\",\"segmentation\":{\"points\":2000},\"sum\":10.0}");
     }
 
     SUBCASE("with multibyte strings") {
-      Countly::Event event("测试", 1);
+      cly::Event event("测试", 1);
       event.addSegmentation("苹果", "美味");
       CHECK(event.serialize() == "{\"count\":1,\"key\":\"测试\",\"segmentation\":{\"苹果\":\"美味\"}}");
     }

tests/main.cpp

@@ -217,7 +217,7 @@ TEST_CASE("events are sent correctly") {
   }
 
   SUBCASE("single event is sent") {
-    Countly::Event event("win", 4);
+    cly::Event event("win", 4);
     event.addSegmentation("points", 100);
     countly.addEvent(event);
     WAIT_FOR_SQLITE(1);
@@ -231,8 +231,8 @@ TEST_CASE("events are sent correctly") {
   }
 
   SUBCASE("two events are sent") {
-    Countly::Event event1("win", 2);
-    Countly::Event event2("achievement", 1);
+    cly::Event event1("win", 2);
+    cly::Event event2("achievement", 1);
     countly.addEvent(event1);
     countly.addEvent(event2);
     WAIT_FOR_SQLITE(1);
@@ -246,7 +246,7 @@ TEST_CASE("events are sent correctly") {
   }
 
   SUBCASE("event with count, sum, duration and segmentation is sent") {
-    Countly::Event event("lose", 3, 10, 100);
+    cly::Event event("lose", 3, 10, 100);
     event.addSegmentation("points", 2000);
     countly.addEvent(event);
 
@@ -262,7 +262,7 @@ TEST_CASE("events are sent correctly") {
 
   SUBCASE("100 events are sent") {
     for (int i = 0; i < 100; i++) {
-      Countly::Event event("click", i);
+      cly::Event event("click", i);
       countly.addEvent(event);
     }
     WAIT_FOR_SQLITE(1);