source/event: Rename Event to EventBase

3 files changed, 42 insertions, 36 deletions

diff --git a/src/sdeventplus/source/event.cpp b/src/sdeventplus/source/event.cpp
index 694c50a..12d4d2b 100644
--- a/src/sdeventplus/source/event.cpp
+++ b/src/sdeventplus/source/event.cpp
@@ -7,20 +7,20 @@ namespace sdeventplus
 namespace source
 {
 
-Event::Event(const char* name, CreateFunc create,
-             const sdeventplus::Event& event, Callback&& callback) :
+EventBase::EventBase(const char* name, CreateFunc create, const Event& event,
+                     Callback&& callback) :
     Base(event, create_source(name, create, event), std::false_type()),
     callback(std::move(callback))
 {
 }
 
-const Event::Callback& Event::get_callback() const
+const EventBase::Callback& EventBase::get_callback() const
 {
     return callback;
 }
 
-sd_event_source* Event::create_source(const char* name, CreateFunc create,
-                                      const sdeventplus::Event& event)
+sd_event_source* EventBase::create_source(const char* name, CreateFunc create,
+                                          const Event& event)
 {
     sd_event_source* source;
     int r = (event.getSdEvent()->*create)(event.get(), &source, eventCallback,
@@ -32,27 +32,27 @@ sd_event_source* Event::create_source(const char* name, CreateFunc create,
     return source;
 }
 
-int Event::eventCallback(sd_event_source* source, void* userdata)
+int EventBase::eventCallback(sd_event_source* source, void* userdata)
 {
-    return sourceCallback<Callback, Event, &Event::get_callback>(
+    return sourceCallback<Callback, EventBase, &EventBase::get_callback>(
         "eventCallback", source, userdata);
 }
 
-Defer::Defer(const sdeventplus::Event& event, Callback&& callback) :
-    Event("sd_event_add_defer", &internal::SdEvent::sd_event_add_defer, event,
-          std::move(callback))
+Defer::Defer(const Event& event, Callback&& callback) :
+    EventBase("sd_event_add_defer", &internal::SdEvent::sd_event_add_defer,
+              event, std::move(callback))
 {
 }
 
-Post::Post(const sdeventplus::Event& event, Callback&& callback) :
-    Event("sd_event_add_post", &internal::SdEvent::sd_event_add_post, event,
-          std::move(callback))
+Post::Post(const Event& event, Callback&& callback) :
+    EventBase("sd_event_add_post", &internal::SdEvent::sd_event_add_post, event,
+              std::move(callback))
 {
 }
 
-Exit::Exit(const sdeventplus::Event& event, Callback&& callback) :
-    Event("sd_event_add_exit", &internal::SdEvent::sd_event_add_exit, event,
-          std::move(callback))
+Exit::Exit(const Event& event, Callback&& callback) :
+    EventBase("sd_event_add_exit", &internal::SdEvent::sd_event_add_exit, event,
+              std::move(callback))
 {
 }
 
diff --git a/src/sdeventplus/source/event.hpp b/src/sdeventplus/source/event.hpp
index 6375d7c..7df8703 100644
--- a/src/sdeventplus/source/event.hpp
+++ b/src/sdeventplus/source/event.hpp
@@ -10,16 +10,16 @@ namespace sdeventplus
 namespace source
 {
 
-class Event : public Base
+class EventBase : public Base
 {
   public:
-    using Callback = std::function<void(Event& source)>;
+    using Callback = std::function<void(EventBase& source)>;
 
   protected:
     using CreateFunc = decltype(&internal::SdEvent::sd_event_add_exit);
 
-    Event(const char* name, CreateFunc create, const sdeventplus::Event& event,
-          Callback&& callback);
+    EventBase(const char* name, CreateFunc create, const Event& event,
+              Callback&& callback);
 
   private:
     Callback callback;
@@ -27,27 +27,27 @@ class Event : public Base
     const Callback& get_callback() const;
 
     static sd_event_source* create_source(const char* name, CreateFunc create,
-                                          const sdeventplus::Event& event);
+                                          const Event& event);
 
     static int eventCallback(sd_event_source* source, void* userdata);
 };
 
-class Defer : public Event
+class Defer : public EventBase
 {
   public:
-    Defer(const sdeventplus::Event& event, Callback&& Callback);
+    Defer(const Event& event, Callback&& Callback);
 };
 
-class Post : public Event
+class Post : public EventBase
 {
   public:
-    Post(const sdeventplus::Event& event, Callback&& callback);
+    Post(const Event& event, Callback&& callback);
 };
 
-class Exit : public Event
+class Exit : public EventBase
 {
   public:
-    Exit(const sdeventplus::Event& event, Callback&& callback);
+    Exit(const Event& event, Callback&& callback);
 };
 
 } // namespace source
diff --git a/test/source/event.cpp b/test/source/event.cpp
index bfd26c3..90edaec 100644
--- a/test/source/event.cpp
+++ b/test/source/event.cpp
@@ -23,8 +23,7 @@ using testing::Return;
 using testing::SaveArg;
 using testing::SetArgPointee;
 
-using UniqueEvent = std::unique_ptr<sdeventplus::Event,
-                                    std::function<void(sdeventplus::Event*)>>;
+using UniqueEvent = std::unique_ptr<Event, std::function<void(Event*)>>;
 
 class EventTest : public testing::Test
 {
@@ -37,13 +36,12 @@ class EventTest : public testing::Test
 
     UniqueEvent make_event(sd_event* event)
     {
-        auto deleter = [this, event](sdeventplus::Event* e) {
+        auto deleter = [this, event](Event* e) {
             EXPECT_CALL(this->mock, sd_event_unref(event))
                 .WillOnce(Return(nullptr));
             delete e;
         };
-        return UniqueEvent(
-            new sdeventplus::Event(event, std::false_type(), &mock), deleter);
+        return UniqueEvent(new Event(event, std::false_type(), &mock), deleter);
     }
 
     void expect_destruct()
@@ -74,7 +72,9 @@ TEST_F(EventTest, DeferConstruct)
         .WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<2>(&handler),
                         Return(0)));
     int completions = 0;
-    Event::Callback callback = [&completions](Event&) { completions++; };
+    EventBase::Callback callback = [&completions](EventBase&) {
+        completions++;
+    };
     Defer defer(*event, std::move(callback));
     EXPECT_EQ(&defer, userdata);
     EXPECT_FALSE(callback);
@@ -99,7 +99,9 @@ TEST_F(EventTest, PostConstruct)
         .WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<2>(&handler),
                         Return(0)));
     int completions = 0;
-    Event::Callback callback = [&completions](Event&) { completions++; };
+    EventBase::Callback callback = [&completions](EventBase&) {
+        completions++;
+    };
     Post post(*event, std::move(callback));
     EXPECT_EQ(&post, userdata);
     EXPECT_FALSE(callback);
@@ -124,7 +126,9 @@ TEST_F(EventTest, ExitConstruct)
         .WillOnce(DoAll(SetArgPointee<1>(expected_source), SaveArg<2>(&handler),
                         Return(0)));
     int completions = 0;
-    Event::Callback callback = [&completions](Event&) { completions++; };
+    EventBase::Callback callback = [&completions](EventBase&) {
+        completions++;
+    };
     Exit exit(*event, std::move(callback));
     EXPECT_EQ(&exit, userdata);
     EXPECT_FALSE(callback);
@@ -142,7 +146,9 @@ TEST_F(EventTest, ConstructFailure)
                                          nullptr))
         .WillOnce(Return(-EINVAL));
     int completions = 0;
-    Event::Callback callback = [&completions](Event&) { completions++; };
+    EventBase::Callback callback = [&completions](EventBase&) {
+        completions++;
+    };
     EXPECT_THROW(Defer(*event, std::move(callback)), SdEventError);
     EXPECT_TRUE(callback);
     EXPECT_EQ(0, completions);