Move strategies from Hue to HueLightFactory.

Reduces complexity of the Hue class and reduces number of parameters on factory function.

Move strategies from Hue to HueLightFactory.
Reduces complexity of the Hue class and reduces number of parameters on factory function.
Jojo-1000 · Moritz Wirger
1 parent 8cffc1b8
Showing 5 changed files with 47 additions and 57 deletions
include/hueplusplus/Hue.h
include/hueplusplus/HueDeviceTypes.h
include/hueplusplus/HueLight.h
src/Hue.cpp
src/HueDeviceTypes.cpp
@@ -35,6 +35,7 @@
 #include "ColorTemperatureStrategy.h"
 #include "Group.h"
 #include "HueCommandAPI.h"
+#include "HueDeviceTypes.h"
 #include "HueLight.h"
 #include "IHttpHandler.h"
@@ -245,7 +246,7 @@ public:
     //! \brief Get group specified by id.
     //! \param id ID of the group.
     //! \returns Group that can be controlled.
-    //! \note Every bridge has a special group 0 which contains all lights 
+    //! \note Every bridge has a special group 0 which contains all lights
     //! and is not visible to getAllGroups().
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when id does not exist
@@ -318,21 +319,11 @@ private:
     std::map<uint8_t, HueLight> lights; //!< Maps ids to HueLights that are controlled by this bridge
     std::map<uint8_t, Group> groups; //!< Maps ids to Groups
-    std::shared_ptr<BrightnessStrategy> simpleBrightnessStrategy; //!< Strategy that is used for controlling the
-                                                                  //!< brightness of lights
-    std::shared_ptr<ColorHueStrategy> simpleColorHueStrategy; //!< Strategy that is used for controlling the
-                                                              //!< color of lights
-    std::shared_ptr<ColorHueStrategy> extendedColorHueStrategy; //!< Strategy that is used for controlling the
-                                                                //!< color of lights
-    std::shared_ptr<ColorTemperatureStrategy> simpleColorTemperatureStrategy; //!< Strategy that is used for controlling
-                                                                              //!< the color temperature of lights
-    std::shared_ptr<ColorTemperatureStrategy> extendedColorTemperatureStrategy; //!< Strategy that is used for
-                                                                                //!< controlling the color
-                                                                                //!< temperature of lights
     std::shared_ptr<const IHttpHandler> http_handler; //!< A IHttpHandler that is used to communicate with the
                                                       //!< bridge
     HueCommandAPI commands; //!< A HueCommandAPI that is used to communicate with the bridge
     APICache stateCache; //!< The state of the hue bridge as it is returned from it
+    HueLightFactory lightFactory;
 };
 } // namespace hueplusplus
@@ -30,14 +30,20 @@
 namespace hueplusplus
 {
-struct MakeHueLight
+class HueLightFactory
 {
-    auto operator()(std::string type, int id, HueCommandAPI commands,
-        std::shared_ptr<BrightnessStrategy> simpleBrightnessStrategy,
-        std::shared_ptr<ColorTemperatureStrategy> extendedColorTemperatureStrategy,
-        std::shared_ptr<ColorTemperatureStrategy> simpleColorTemperatureStrategy,
-        std::shared_ptr<ColorHueStrategy> extendedColorHueStrategy,
-        std::shared_ptr<ColorHueStrategy> simpleColorHueStrategy) -> HueLight;
+public:
+    HueLightFactory(const HueCommandAPI& commands);
+
+    HueLight createLight(const std::string& type, int id);
+
+private:
+    HueCommandAPI commands;
+    std::shared_ptr<BrightnessStrategy> simpleBrightness;
+    std::shared_ptr<ColorTemperatureStrategy> simpleColorTemperature;
+    std::shared_ptr<ColorTemperatureStrategy> extendedColorTemperature;
+    std::shared_ptr<ColorHueStrategy> simpleColorHue;
+    std::shared_ptr<ColorHueStrategy> extendedColorHue;
 };
 } // namespace hueplusplus
@@ -97,8 +97,7 @@ enum class ColorType
 //! Provides methods to query and control lights.
 class HueLight
 {
-    friend class Hue;
-    friend struct MakeHueLight;
+    friend class HueLightFactory;
     friend class SimpleBrightnessStrategy;
     friend class SimpleColorHueStrategy;
     friend class ExtendedColorHueStrategy;
@@ -31,13 +31,7 @@
 #include <stdexcept>
 #include <thread>
-#include "hueplusplus/ExtendedColorHueStrategy.h"
-#include "hueplusplus/ExtendedColorTemperatureStrategy.h"
-#include "hueplusplus/HueDeviceTypes.h"
 #include "hueplusplus/HueExceptionMacro.h"
-#include "hueplusplus/SimpleBrightnessStrategy.h"
-#include "hueplusplus/SimpleColorHueStrategy.h"
-#include "hueplusplus/SimpleColorTemperatureStrategy.h"
 #include "hueplusplus/UPnP.h"
 #include "hueplusplus/Utils.h"
@@ -140,14 +134,10 @@ Hue::Hue(const std::string&amp; ip, const int port, const std::string&amp; username,
     : ip(ip),
       port(port),
       username(username),
-      simpleBrightnessStrategy(std::make_shared<SimpleBrightnessStrategy>()),
-      simpleColorHueStrategy(std::make_shared<SimpleColorHueStrategy>()),
-      extendedColorHueStrategy(std::make_shared<ExtendedColorHueStrategy>()),
-      simpleColorTemperatureStrategy(std::make_shared<SimpleColorTemperatureStrategy>()),
-      extendedColorTemperatureStrategy(std::make_shared<ExtendedColorTemperatureStrategy>()),
       http_handler(std::move(handler)),
       commands(ip, port, username, http_handler),
-      stateCache("", commands, refreshDuration)
+      stateCache("", commands, refreshDuration),
+      lightFactory(commands)
 {}
 std::string Hue::getBridgeIP()
@@ -191,6 +181,7 @@ std::string Hue::requestUsername()
                 // Update commands with new username and ip
                 commands = HueCommandAPI(ip, port, username, http_handler);
                 stateCache = APICache("", commands, stateCache.getRefreshDuration());
+                lightFactory = HueLightFactory(commands);
                 std::cout << "Success! Link button was pressed!\n";
                 std::cout << "Username is \"" << username << "\"\n";
                 break;
@@ -231,7 +222,7 @@ HueLight&amp; Hue::getLight(int id)
     auto pos = lights.find(id);
     if (pos != lights.end())
     {
-        pos->second.state.refresh();
+        pos->second.refresh();
         return pos->second;
     }
     const nlohmann::json& lightsCache = stateCache.getValue()["lights"];
@@ -241,8 +232,7 @@ HueLight&amp; Hue::getLight(int id)
         throw HueException(CURRENT_FILE_INFO, "Light id is not valid");
     }
     std::string type = lightsCache[std::to_string(id)]["modelid"].get<std::string>();
-    auto light = MakeHueLight()(type, id, commands, simpleBrightnessStrategy, extendedColorTemperatureStrategy,
-        simpleColorTemperatureStrategy, extendedColorHueStrategy, simpleColorHueStrategy);
+    auto light = lightFactory.createLight(type, id);
     lights.emplace(id, light);
     return lights.find(id)->second;
 }
@@ -534,5 +524,6 @@ void Hue::setHttpHandler(std::shared_ptr&lt;const IHttpHandler&gt; handler)
     http_handler = handler;
     commands = HueCommandAPI(ip, port, username, handler);
     stateCache = APICache("", commands, stateCache.getRefreshDuration());
+    lightFactory = HueLightFactory(commands);
 }
 } // namespace hueplusplus
@@ -24,7 +24,13 @@
 #include <set>
+#include "hueplusplus/ExtendedColorHueStrategy.h"
+#include "hueplusplus/ExtendedColorTemperatureStrategy.h"
+#include "hueplusplus/HueDeviceTypes.h"
 #include "hueplusplus/HueExceptionMacro.h"
+#include "hueplusplus/SimpleBrightnessStrategy.h"
+#include "hueplusplus/SimpleColorHueStrategy.h"
+#include "hueplusplus/SimpleColorTemperatureStrategy.h"
 namespace hueplusplus
 {
@@ -60,8 +66,7 @@ const std::set&lt;std::string&gt;&amp; getNoColorTypes()
 const std::set<std::string>& getNonDimmableTypes()
 {
-    static const std::set<std::string> c_NON_DIMMABLE_TYPES
-        = {"Plug 01"};
+    static const std::set<std::string> c_NON_DIMMABLE_TYPES = {"Plug 01"};
     return c_NON_DIMMABLE_TYPES;
 }
@@ -75,52 +80,50 @@ const std::set&lt;std::string&gt;&amp; getTemperatureLightTypes()
 }
 } // namespace
-auto MakeHueLight::operator()(std::string type, int id, HueCommandAPI commands,
-    std::shared_ptr<BrightnessStrategy> simpleBrightnessStrategy,
-    std::shared_ptr<ColorTemperatureStrategy> extendedColorTemperatureStrategy,
-    std::shared_ptr<ColorTemperatureStrategy> simpleColorTemperatureStrategy,
-    std::shared_ptr<ColorHueStrategy> extendedColorHueStrategy,
-    std::shared_ptr<ColorHueStrategy> simpleColorHueStrategy) -> HueLight
+HueLightFactory::HueLightFactory(const HueCommandAPI& commands)
+    : commands(commands),
+      simpleBrightness(std::make_shared<SimpleBrightnessStrategy>()),
+      simpleColorHue(std::make_shared<SimpleColorHueStrategy>()),
+      extendedColorHue(std::make_shared<ExtendedColorHueStrategy>()),
+      simpleColorTemperature(std::make_shared<SimpleColorTemperatureStrategy>()),
+      extendedColorTemperature(std::make_shared<ExtendedColorTemperatureStrategy>())
+{}
+
+HueLight HueLightFactory::createLight(const std::string& type, int id)
 {
     if (getGamutBTypes().count(type))
     {
-        auto light = HueLight(
-            id, commands, simpleBrightnessStrategy, extendedColorTemperatureStrategy, extendedColorHueStrategy);
+        auto light = HueLight(id, commands, simpleBrightness, extendedColorTemperature, extendedColorHue);
         light.colorType = ColorType::GAMUT_B;
         return light;
     }
-
     else if (getGamutCTypes().count(type))
     {
-        auto light = HueLight(
-            id, commands, simpleBrightnessStrategy, extendedColorTemperatureStrategy, extendedColorHueStrategy);
+        auto light = HueLight(id, commands, simpleBrightness, extendedColorTemperature, extendedColorHue);
         light.colorType = ColorType::GAMUT_C;
         return light;
     }
-
     else if (getGamutATypes().count(type))
     {
-        auto light = HueLight(id, commands, simpleBrightnessStrategy, nullptr, simpleColorHueStrategy);
+        auto light = HueLight(id, commands, simpleBrightness, nullptr, simpleColorHue);
         light.colorType = ColorType::GAMUT_A;
         return light;
     }
-
     else if (getNoColorTypes().count(type))
     {
-        auto light = HueLight(id, commands, simpleBrightnessStrategy, nullptr, nullptr);
+        auto light = HueLight(id, commands, simpleBrightness, nullptr, nullptr);
         light.colorType = ColorType::NONE;
         return light;
     }
-
-    else if (getNonDimmableTypes().count(type)) {
+    else if (getNonDimmableTypes().count(type))
+    {
         auto light = HueLight(id, commands);
         light.colorType = ColorType::NONE;
         return light;
     }
-
     else if (getTemperatureLightTypes().count(type))
     {
-        auto light = HueLight(id, commands, simpleBrightnessStrategy, simpleColorTemperatureStrategy, nullptr);
+        auto light = HueLight(id, commands, simpleBrightness, simpleColorTemperature, nullptr);
         light.colorType = ColorType::TEMPERATURE;
         return light;
     }