made some stuff working 😠 @Jonas

FlippR-Driver/CMakeLists.txt

@@ -143,7 +143,8 @@ endif()
 target_link_libraries(${PROJECT_NAME} PRIVATE ${Threads_LIBRARIES})
 
 ####################### POCO ##############################
-find_package(Poco REQUIRED COMPONENTS Foundation Net JSON )
+include(${CMAKE_SOURCE_DIR}/lib/PocoConfig.cmake)
+#find_package(Poco REQUIRED COMPONENTS Foundation Net JSON )
 if(NOT Poco_FOUND)
     message(FATAL_ERROR, "Could not find libPoco")
 endif()

FlippR-Driver/src/input/detail/EventNotifier.h

@@ -8,6 +8,10 @@
 #ifndef INPUT_IMPL_EVENTNOTIFIER_H_
 #define INPUT_IMPL_EVENTNOTIFIER_H_
 
+#include <set>
+#include <thread>
+#include <mutex>
+
 #include "input/EventNotifier.h"
 
 #include "input/Event.h"
@@ -16,10 +20,6 @@
 #include "utility/BlockingQueue.hpp"
 #include "utility/IBlockingQueue.h"
 
-#include <set>
-#include <thread>
-#include <mutex>
-
 
 namespace flippR_driver
 {

FlippR-Driver/src/utility/SocketHandler.cpp

@@ -8,13 +8,13 @@ namespace flippR_driver
 {
 namespace utility
 {
-using namespace nlohmann;
+//using namespace nlohmann;
 
-SocketHandler::SocketHandler(boost::asio::io_service &service, std::string socket_file) : socket(boost::asio::io_service{})
+SocketHandler::SocketHandler(std::string socket_file)
 {
-  this->socket.connect(socket_file);
+  //this->socket.connect(socket_file);
 }
-
+/*
 SocketHandler::create_client(const std::string& socket_file)
 {
     this->socket.connect(socket_file);
@@ -31,6 +31,6 @@ void SocketHandler::write_to_socket(json &json)
 
   boost::asio::write(this->socket, boost::asio::buffer(json_data, json_data.length()));
 }
-
+*/
 }
 }

FlippR-Driver/src/utility/SocketHandler.h

@@ -18,7 +18,7 @@ public:
   SocketHandler(std::string socket_file);
 
 protected:
-  boost::asio::local::stream_protocol::socket socket;
+  Poco::Net::Socket socket;
 
 protected:
   void write_to_socket(std::string &data);

FlippR-Driver/src/utility/networking/input/InputSocketHandler.cpp

@@ -0,0 +1,44 @@
+//
+// Created by rhetenor on 27.11.18.
+//
+
+#include "InputSocketHandler.h"
+
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+#include "json/json.hpp"
+
+namespace flippR_driver
+{
+namespace utility
+{
+using namespace nlohmann;
+
+InputSocketHandler::InputSocketHandler()
+{}
+
+void InputSocketHandler::handle(flippR_driver::input::Event &event)
+{
+  json event_serialization = serialize_event(event);
+
+//  write_to_socket(event_serialization);
+}
+
+//json InputSocketHandler::serialize_event(input::Event &event)
+//{
+//  json serialized_event = json("event");
+//
+//  serialized_event["name"] = event.name;
+//
+//  std::time_t activation_time = std::chrono::system_clock::to_time_t(event.last_activation);
+//  boost::posix_time::ptime posix_time = boost::posix_time::from_time_t(activation_time);
+//  serialized_event["activation_time"] = boost::posix_time::to_simple_string(posix_time); // todo learn to write time right
+//
+//  serialized_event["priority"] = event.priority;
+//
+//  return serialized_event;
+//}
+
+
+}
+}

FlippR-Driver/src/utility/networking/input_connection/InputSocketHandler.cpp

@@ -1,43 +0,0 @@
-//
-// Created by rhetenor on 27.11.18.
-//
-
-#include "InputSocketHandler.h"
-
-#include <boost/date_time/posix_time/posix_time.hpp>
-
-#include "json.hpp"
-
-namespace flippR_driver
-{
-namespace utility
-{
-using namespace nlohmann;
-
-InputSocketHandler::InputSocketHandler(boost::asio::io_service &service, std::string socket_file) : SocketHandler(service, std::move(socket_file)) {}
-
-void InputSocketHandler::handle(flippR_driver::input::Event &event)
-{
-  json event_serialization = serialize_event(event);
-
-  write_to_socket(event_serialization);
-}
-
-json InputSocketHandler::serialize_event(input::Event &event)
-{
-  json serialized_event = json("event");
-
-  serialized_event["name"] = event.name;
-
-  std::time_t activation_time = std::chrono::system_clock::to_time_t(event.last_activation);
-  boost::posix_time::ptime posix_time = boost::posix_time::from_time_t(activation_time);
-  serialized_event["activation_time"] = boost::posix_time::to_simple_string(posix_time); // todo learn to write time right
-
-  serialized_event["priority"] = event.priority;
-
-  return serialized_event;
-}
-
-
-}
-}

FlippR-Driver/src/utility/networking/output/OutputRequestHandler.cpp

@@ -50,7 +50,8 @@ void OutputRequestHandler::handleRequest(HTTPServerRequest &request,
   }
   catch(const Poco::InvalidArgumentException &e)
   {
-    response.setStatusAndReason(HTTPServerResponse::HTTP_REASON_BAD_REQUEST, e.displayText());
+//    TODO not compiling
+//    response.setStatusAndReason(HTTPServerResponse::HTTP_REASON_BAD_REQUEST, e.displayText());
   }
 }
 
@@ -162,8 +163,9 @@ void OutputRequestHandler::parseDisplay(const std::string& item_name, const std:
   {
     try
     {
-        unsigned int score = std::stoi(score);
-        display->write_score(score);
+      //TODO not compiling
+//        unsigned int score = std::stoi(score);
+//        display->write_score(score);
     }
     catch(std::invalid_argument &e)
     {

FlippR-Driver/src/utility/networking/output/OutputRequestHandlerFactory.h

@@ -15,7 +15,7 @@ namespace flippR_driver
 namespace utility
 {
 
-class OutputRequestHandlerFactory :: public Poco::Net::HTTPRequestHandlerFactory
+class OutputRequestHandlerFactory : public Poco::Net::HTTPRequestHandlerFactory
 {
 public:
   explicit OutputRequestHandlerFactory(std::shared_ptr<output::OutputDriver> output_driver);

FlippR-Driver/src/utility/networking/output/OutputSocketHandler.h

@@ -5,7 +5,7 @@
 #ifndef FLIPPR_DRIVER_OUTPUTSOCKETHANDLER_H
 #define FLIPPR_DRIVER_OUTPUTSOCKETHANDLER_H
 
-#include "SocketHandler.h"
+#include "utility/SocketHandler.h"
 #include "output/OutputDriver.h"
 
 namespace flippR_driver

FlippR-Driver/tests/input/TestDetector.cpp

@@ -11,14 +11,15 @@
 
 #include <map>
 #include <typeinfo>
+#include <thread>
 
 
 #define private public
 
-#include "input/IEventNotifier.h"
+#include "input/EventNotifier.h"
 #include "input/DistributingEvent.h"
-#include "input/Detector.h"
-#include "input/IInputGPIOInterface.h"
+#include "input/detail/Detector.h"
+#include "input/detail/InputPinController.h"
 #include "utility/LoggerFactory.h"
 
 
@@ -34,8 +35,8 @@ SCENARIO("Creating a Detector object", "")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<IEventNotifier> event_notifier_mock;
-    Mock<IInputGPIOInterface> gpio_interface_mock;
+    Mock<EventNotifier> event_notifier_mock;
+    Mock<InputPinController> gpio_interface_mock;
 
     Fake(Dtor(gpio_interface_mock));
     When(Method(gpio_interface_mock, read_data)).AlwaysReturn(false);
@@ -47,7 +48,7 @@ SCENARIO("Creating a Detector object", "")
 
     WHEN("Detector is created")
     {
-      Detector detector(std::unique_ptr<IInputGPIOInterface>(&gpio_interface_mock.get()), events);
+      detail::Detector detector(std::unique_ptr<InputPinController>(&gpio_interface_mock.get()), events);
       THEN("a thread should be created")
       {
         REQUIRE(typeid(detector.detect_thread).hash_code() == typeid(std::thread).hash_code());
@@ -58,12 +59,12 @@ SCENARIO("Creating a Detector object", "")
 
 SCENARIO("There are events at the input", "")
 {
-  GIVEN("An IEventNofifier, three Events and an IInputGPIOInterface")
+  GIVEN("An IEventNofifier, three Events and an InputPinController")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<IEventNotifier> event_notifier_mock;
-    Mock<IInputGPIOInterface> gpio_interface_mock;
+    Mock<EventNotifier> event_notifier_mock;
+    Mock<InputPinController> gpio_interface_mock;
 
     Fake(Dtor(gpio_interface_mock));
     When(Method(gpio_interface_mock, read_data)).AlwaysDo([](char c){return c==2;});
@@ -71,7 +72,7 @@ SCENARIO("There are events at the input", "")
     Fake(Dtor(event_notifier_mock));
     When(Method(event_notifier_mock, distribute_event)).AlwaysReturn();
 
-    std::shared_ptr<IEventNotifier> event_notifier;
+    std::shared_ptr<EventNotifier> event_notifier;
     DistributingEvent event1(1, '1', "event 1", std::chrono::milliseconds(0), event_notifier);
     DistributingEvent event2(2, '2', "event 2", std::chrono::milliseconds(0), event_notifier);
     DistributingEvent event3(3, '3', "event 3", std::chrono::milliseconds(0), event_notifier);
@@ -85,7 +86,7 @@ SCENARIO("There are events at the input", "")
 
     WHEN("an event can be found at gpio interface")
     {
-      Detector detector(std::unique_ptr<IInputGPIOInterface>(&gpio_interface_mock.get()), events);
+      detail::Detector detector(std::unique_ptr<InputPinController>(&gpio_interface_mock.get()), events);
       std::this_thread::sleep_for(std::chrono::milliseconds(50));
       THEN("the event should be distributed")
       {
@@ -99,12 +100,12 @@ SCENARIO("There are events at the input", "")
 
 SCENARIO("There are events at the input but no suitable event in map", "")
 {
-  GIVEN("An IEventNofifier, three Events and an IInputGPIOInterface")
+  GIVEN("An IEventNofifier, three Events and an InputPinController")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<IEventNotifier> event_notifier_mock;
-    Mock<IInputGPIOInterface> gpio_interface_mock;
+    Mock<EventNotifier> event_notifier_mock;
+    Mock<InputPinController> gpio_interface_mock;
 
     Fake(Dtor(gpio_interface_mock));
     When(Method(gpio_interface_mock, read_data)).AlwaysDo([](char c){return c==4;});
@@ -112,7 +113,7 @@ SCENARIO("There are events at the input but no suitable event in map", "")
     Fake(Dtor(event_notifier_mock));
     When(Method(event_notifier_mock, distribute_event)).AlwaysReturn();
 
-    std::shared_ptr<IEventNotifier> event_notifier;
+    std::shared_ptr<EventNotifier> event_notifier;
     DistributingEvent event1(1, '1', "event 1", std::chrono::milliseconds(0), event_notifier);
     DistributingEvent event2(2, '2', "event 2", std::chrono::milliseconds(0), event_notifier);
     DistributingEvent event3(3, '3', "event 3", std::chrono::milliseconds(0), event_notifier);
@@ -125,7 +126,7 @@ SCENARIO("There are events at the input but no suitable event in map", "")
 
     WHEN("an event can be found at gpio interface")
     {
-      Detector detector(std::unique_ptr<IInputGPIOInterface>(&gpio_interface_mock.get()), events);
+      detail::Detector detector(std::unique_ptr<InputPinController>(&gpio_interface_mock.get()), events);
       std::this_thread::sleep_for(std::chrono::milliseconds(10));
       THEN("the event should be distributed")
       {

FlippR-Driver/tests/input/TestEventHandler.cpp

@@ -8,14 +8,13 @@
 #include "catch.hpp"
 #include "fakeit.hpp"
 
-#include "utility/LoggerFactory.h"
-#include "input/EventHandler.h"
-#include "input/IInputDriver.h"
-
-
 // testing purposes
 #define private public
 
+#include "utility/LoggerFactory.h"
+#include "input/detail/EventHandler.h"
+#include "input/InputDriver.h"
+
 
 using namespace fakeit;
 using namespace flippR_driver::utility;
@@ -26,15 +25,15 @@ SCENARIO("An EventHandler gets created", "[construction}")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<flippR_driver::input::IInputDriver> input_driver_mock;
+    Mock<flippR_driver::input::InputDriver> input_driver_mock;
     Fake(Dtor(input_driver_mock));
     When(Method(input_driver_mock, register_event_handler)).AlwaysReturn();
     When(Method(input_driver_mock, unregister_event_handler)).AlwaysReturn();
 
     WHEN("the event handler gets created")
     {
-      std::shared_ptr<flippR_driver::input::IInputDriver> driver_ptr(&input_driver_mock.get());
-      flippR_driver::input::EventHandler handler(driver_ptr);
+      std::shared_ptr<flippR_driver::input::InputDriver> driver_ptr(&input_driver_mock.get());
+      flippR_driver::input::detail::EventHandler handler(driver_ptr);
 
       THEN("It should register itself at the input_driver")
       {

FlippR-Driver/tests/input/TestEventNotifier.cpp

@@ -9,17 +9,17 @@
 #include "catch.hpp"
 #include "fakeit.hpp"
 
-
-#include "utility/LoggerFactory.h"
-#include "input/IEventHandler.h"
-#include "utility/IBlockingQueue.h"
-
-
 // testing purposes
 #define private public
 
+#include "utility/LoggerFactory.h"
+#include "input/EventHandler.h"
+#include "utility/IBlockingQueue.h"
+#include "input/detail/EventNotifier.h"
+
 #include "input/EventNotifier.h"
 
+
 using namespace flippR_driver;
 using namespace input;
 using namespace fakeit;
@@ -38,7 +38,7 @@ SCENARIO("An EventNotifier gets created", "[construction]")
     When(Method(queue_mock, pop)).AlwaysDo([event](){return event;});
     Fake(Dtor(queue_mock));
 
-    EventNotifier notifier(&(queue_mock.get()));
+    input::detail::EventNotifier notifier(&(queue_mock.get()));
     THEN("It sets the running variable to true")
     {
       REQUIRE(notifier.is_running);
@@ -63,11 +63,11 @@ SCENARIO("An EventHandler gets [un]registered at the notifier", "[un-register no
     When(Method(queue_mock, pop)).AlwaysDo([event](){return event;});
     Fake(Dtor(queue_mock));
 
-    Mock<IEventHandler> event_handler_mock;
+    Mock<input::EventHandler> event_handler_mock;
     Fake(Method(event_handler_mock, handle));
     Fake(Dtor(event_handler_mock));
 
-    EventNotifier notifier(&(queue_mock.get()));
+    input::detail::EventNotifier notifier(&(queue_mock.get()));
 
     WHEN("The EventHandler gets registered at the eventNotifier")
     {
@@ -105,7 +105,7 @@ SCENARIO("An event should be distributed", "[distribute]")
     When(Method(queue_mock, pop)).AlwaysDo([event](){return event;});
     Fake(Dtor(queue_mock));
 
-    EventNotifier notifier(&(queue_mock.get()));
+    input::detail::EventNotifier notifier(&(queue_mock.get()));
 
     WHEN("The event comes in")
     {
@@ -126,7 +126,7 @@ SCENARIO("The EventHandler gets notified")
   {
     Event event(0, 0, "test");
 
-    Mock<IEventHandler> event_handler_mock;
+    Mock<input::EventHandler> event_handler_mock;
     When(Method(event_handler_mock, handle)).AlwaysReturn();
     Fake(Dtor(event_handler_mock));
 
@@ -137,7 +137,7 @@ SCENARIO("The EventHandler gets notified")
     When(Method(queue_mock, pop)).AlwaysDo([test_event](void){return test_event;});
     Fake(Dtor(queue_mock));
 
-    EventNotifier notifier(&(queue_mock.get()));
+    input::detail::EventNotifier notifier(&(queue_mock.get()));
 
     notifier.event_handlers.insert(&(event_handler_mock.get()));
 

FlippR-Driver/tests/input/TestInputDriver.cpp

@@ -12,10 +12,10 @@
 // testing purposes
 #define private public
 
-#include "input/InputDriver.h"
+#include "input/detail/InputDriver.h"
 
-#include "input/IEventNotifier.h"
-#include "input/IDetector.h"
+#include "input/EventNotifier.h"
+#include "input/Detector.h"
 
 
 using namespace fakeit;
@@ -29,19 +29,17 @@ SCENARIO("An InputDriver gets created", "[construction}")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<IDetector> detector_mock;
+    Mock<Detector> detector_mock;
     Fake(Dtor(detector_mock));
 
-    Mock<IEventNotifier> event_notifier_mock;
+    Mock<EventNotifier> event_notifier_mock;
     Fake(Dtor(event_notifier_mock));
-    Mock<IEventHandler> event_handler_mock;
-    Fake(Dtor(event_handler_mock));
     WHEN("The InputDriver gets created")
     {
-      std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
+      std::shared_ptr<EventNotifier> event_notifier_ptr(&event_notifier_mock.get());
       std::map<std::string, std::shared_ptr<Event>> events;
 
-      InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
+      input::detail::InputDriver input_driver(event_notifier_ptr, std::unique_ptr<Detector>(&detector_mock.get()), events);
 
       THEN("It saves the EventNotifier and the Detector")
       {
@@ -58,23 +56,23 @@ SCENARIO("An EventHandler [un]registers at the driver", "[un-register]")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<flippR_driver::input::IDetector> detector_mock;
+    Mock<flippR_driver::input::Detector> detector_mock;
     Fake(Dtor(detector_mock));
 
-    Mock<IEventHandler> event_handler_mock;
+    Mock<input::EventHandler> event_handler_mock;
     Fake(Method(event_handler_mock, handle));
     Fake(Dtor(event_handler_mock));
 
-    Mock<flippR_driver::input::IEventNotifier> event_notifier_mock;
+    Mock<flippR_driver::input::EventNotifier> event_notifier_mock;
     Fake(Method(event_notifier_mock, register_event_handler));
     Fake(Method(event_notifier_mock, unregister_event_handler));
     Fake(Dtor(event_notifier_mock));
 
-    std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
+    std::shared_ptr<EventNotifier> event_notifier_ptr(&event_notifier_mock.get());
 
     std::map<std::string, std::shared_ptr<Event>> events;
 
-    InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
+    input::detail::InputDriver input_driver(event_notifier_ptr, std::unique_ptr<Detector>(&detector_mock.get()), events);
 
     WHEN("The EventHandler registers at the driver")
     {
@@ -105,16 +103,16 @@ SCENARIO("An Input Driver is created normally", "")
   {
     LoggerFactory::CreateInputTestLogger();
 
-    Mock<flippR_driver::input::IDetector> detector_mock;
+    Mock<flippR_driver::input::Detector> detector_mock;
     Fake(Dtor(detector_mock));
 
-    Mock<IEventHandler> event_handler_mock;
+    Mock<input::EventHandler> event_handler_mock;
     Fake(Dtor(event_handler_mock));
 
-    Mock<flippR_driver::input::IEventNotifier> event_notifier_mock;
+    Mock<flippR_driver::input::EventNotifier> event_notifier_mock;
     Fake(Dtor(event_notifier_mock));
 
-    std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
+    std::shared_ptr<EventNotifier> event_notifier_ptr(&event_notifier_mock.get());
 
     Event event1('a', 2, "e1");
     auto event1_ptr = std::make_shared<Event>(event1  );
@@ -129,7 +127,7 @@ SCENARIO("An Input Driver is created normally", "")
     events.emplace("e4", std::make_shared<Event>(event4));
 
 
-    InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
+    input::detail::InputDriver input_driver(event_notifier_ptr, std::unique_ptr<Detector>(&detector_mock.get()), events);
 
     WHEN("Someone asks for an event that is registered")
     {
@@ -147,7 +145,7 @@ SCENARIO("An Input Driver is created normally", "")
 
       THEN("the obtained event should be null")
       {
-        REQUIRE(event->name == "ERROR");
+        REQUIRE(event->get()->name == "ERROR");
       }
     }
   }