Changeset 28:9b3c2d3ea9f3 in vscpl for src/hu/varadiistvan/scpl/io/_win32

Timestamp:

12/15/22 15:56:11 (2 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

Event object creation is moved into a factory.

Location:

src/hu/varadiistvan/scpl/io/_win32

Files:

• BufferedStream.cc (modified) (1 diff)
• BufferedStream.h (modified) (1 diff)
• Event.h (modified) (4 diffs)
• EventFactory.cc (added)
• EventFactory.h (added)
• EventFailable.h (modified) (2 diffs)
• LocalServerSocketBase.h (modified) (1 diff)
• LocalSocket.h (modified) (1 diff)
• Makefile.am (modified) (2 diffs)
• Overlappable.h (modified) (2 diffs)
• WaitableEvent.h (modified) (2 diffs)

src/hu/varadiistvan/scpl/io/_win32/BufferedStream.cc

@@ -40 +40 @@
 //------------------------------------------------------------------------------
 
-BufferedStream::BufferedStream(Waiter* waiter, HANDLE handle,
+BufferedStream::BufferedStream(std::unique_ptr<EventFactory> eventFactory,
+                               Waiter* waiter, HANDLE handle,
                                size_t readingCapacity, size_t writingCapacity) :
-    Overlappable(waiter, handle),
+    Overlappable(std::move(eventFactory), waiter, handle),
     readingBuffer( (readingCapacity==0) ? 0 :
                    new ReadingBuffer(readingCapacity, this)),

src/hu/varadiistvan/scpl/io/_win32/BufferedStream.h

@@ -76 +76 @@
      * Construct the buffered stream.
      */
-    BufferedStream(Waiter* waiter = 0, HANDLE handle = 0,
+    BufferedStream(std::unique_ptr<EventFactory> eventFactory,
+                   Waiter* waiter = 0, HANDLE handle = 0,
                    size_t readingCapacity = DEFAULT_CAPACITY,
                    size_t writingCapacity = DEFAULT_CAPACITY);

src/hu/varadiistvan/scpl/io/_win32/Event.h

@@ -133 +133 @@
 inline Event::Event(EventFailable& eventFailable) :
     eventFailable(eventFailable),
-    handle(CreateEvent(0, true, false, 0)),
+    handle(eventFailable.createEvent()),
     waiter(0)
 {
@@ -144 +144 @@
 {
     removeFromWaiter();
-    CloseHandle(handle);
+    eventFailable.destroyEvent(handle);
 }
 
@@ -172 +172 @@
 inline void Event::fire()
 {
-    if (!SetEvent(handle)) {
+    if (!eventFailable.setEvent(handle)) {
         eventFailable.setErrorCode(GetLastError());
     }
@@ -181 +181 @@
 inline bool Event::clear()
 {
-    if (!ResetEvent(handle)) {
+    if (!eventFailable.resetEvent(handle)) {
         eventFailable.setErrorCode(GetLastError());
         return false;

src/hu/varadiistvan/scpl/io/_win32/EventFailable.h

@@ -33 +33 @@
 #include "../Failable.h"
 
+#include "EventFactory.h"
+
+#include <memory>
+
 //------------------------------------------------------------------------------
 
@@ -51 +55 @@
 class EventFailable : public Failable
 {
+protected:
+    /**
+     * The event factory for this object.
+     */
+    std::unique_ptr<EventFactory> eventFactory;
+
+protected:
+    /**
+     * Construct the object with the given event factory.
+     */
+    EventFailable(std::unique_ptr<EventFactory> eventFactory);
+
+    /**
+     * Create an event for this object using the event factory.
+     */
+    HANDLE createEvent();
+
+    /**
+     * Set the event represented by the given handle using the event factory.
+     */
+    bool setEvent(HANDLE handle);
+
+    /**
+     * Set the event represented by the given handle using the event factory.
+     */
+    bool resetEvent(HANDLE handle);
+
+    /**
+     * Destroy the event represented by the given handle using the event factory.
+     */
+    void destroyEvent(HANDLE handle);
+
     friend class Event;
 };
+
+//------------------------------------------------------------------------------
+// Inline definitions
+//------------------------------------------------------------------------------
+
+inline EventFailable::EventFailable(std::unique_ptr<EventFactory> eventFactory) :
+    eventFactory(std::move(eventFactory))
+{
+}
+
+//------------------------------------------------------------------------------
+
+inline HANDLE EventFailable::createEvent()
+{
+    return eventFactory->createEvent();
+}
+
+//------------------------------------------------------------------------------
+
+inline bool EventFailable::setEvent(HANDLE handle)
+{
+    return eventFactory->setEvent(handle);
+}
+
+//------------------------------------------------------------------------------
+
+inline bool EventFailable::resetEvent(HANDLE handle)
+{
+    return eventFactory->resetEvent(handle);
+}
+
+//------------------------------------------------------------------------------
+
+inline void EventFailable::destroyEvent(HANDLE handle)
+{
+    eventFactory->destroyEvent(handle);
+}
 
 //------------------------------------------------------------------------------

src/hu/varadiistvan/scpl/io/_win32/LocalServerSocketBase.h

@@ -83 +83 @@
 
 inline LocalServerSocketBase::LocalServerSocketBase(Waiter* waiter) :
-    Overlappable(waiter)
+    Overlappable(std::make_unique<EventFactory>(), waiter)
 {
 }

src/hu/varadiistvan/scpl/io/_win32/LocalSocket.h

@@ -89 +89 @@
 inline LocalSocket::LocalSocket(Waiter* waiter, HANDLE handle,
                                 size_t readingCapacity, size_t writingCapacity):
-    BufferedStream(waiter, handle, readingCapacity, writingCapacity)
+    BufferedStream(std::make_unique<EventFactory>(),
+                   waiter, handle, readingCapacity, writingCapacity)
 {
 }

src/hu/varadiistvan/scpl/io/_win32/Makefile.am

@@ -7 +7 @@
 libvscpl_io_win32_la_SOURCES=\
         Event.cc                \
+        EventFactory.cc         \
         Overlapped.cc           \
         Waiter.cc               \
@@ -18 +19 @@
 include_vscpl_io_win32dir=$(includedir)/hu/varadiistvan/scpl/io/_win32
 include_vscpl_io_win32_HEADERS=\
+        EventFactory.h          \
         EventFailable.h         \
         Overlappable.h          \

src/hu/varadiistvan/scpl/io/_win32/Overlappable.h

@@ -67 +67 @@
      * Construct the object.
      */
-    Overlappable(Waiter* waiter = 0, HANDLE handle = 0);
+    Overlappable(std::unique_ptr<EventFactory> eventFactory,
+                 Waiter* waiter = 0, HANDLE handle = 0);
 
 public:
@@ -97 +98 @@
 //------------------------------------------------------------------------------
 
-inline Overlappable::Overlappable(Waiter* waiter, HANDLE handle) :
+inline Overlappable::Overlappable(std::unique_ptr<EventFactory> eventFactory,
+                                  Waiter* waiter, HANDLE handle) :
+    EventFailable(std::move(eventFactory)),
     waiter(waiter),
     handle(handle)

src/hu/varadiistvan/scpl/io/_win32/WaitableEvent.h

@@ -41 +41 @@
  * An event which can be waited for.
  */
-class WaitableEvent : public Event, public EventFailable
+class WaitableEvent : public EventFailable, public Event
 {
 public:
@@ -61 +61 @@
 
 inline WaitableEvent::WaitableEvent(Waiter* waiter) :
+    EventFailable(std::make_unique<EventFactory>()),
     Event(static_cast<EventFailable&>(*this))
 {