Add documentation for Group and StateTransaction.

Add sections to documentation of large classes.

Add documentation for Group and StateTransaction.
Add sections to documentation of large classes.
Jojo-1000 · Moritz Wirger
1 parent 48dd0747
Showing 22 changed files with 613 additions and 222 deletions
include/hueplusplus/APICache.h
include/hueplusplus/Group.h
include/hueplusplus/Hue.h
include/hueplusplus/HueCommandAPI.h
include/hueplusplus/HueException.h
include/hueplusplus/HueExceptionMacro.h
include/hueplusplus/HueLight.h
include/hueplusplus/StateTransaction.h
src/APICache.cpp
src/ExtendedColorHueStrategy.cpp
src/ExtendedColorTemperatureStrategy.cpp
src/Group.cpp
src/Hue.cpp
src/HueDeviceTypes.cpp
src/HueLight.cpp
src/SimpleBrightnessStrategy.cpp
src/SimpleColorHueStrategy.cpp
src/SimpleColorTemperatureStrategy.cpp
src/StateTransaction.cpp
test/mocks/mock_HueLight.h
@@ -45,19 +45,19 @@ public:
     //! \throws HueException when response contained no body
     //! \throws HueAPIResponseException when response contains an error
     //! \throws nlohmann::json::parse_error when response could not be parsed
-    void Refresh();
+    void refresh();
     //! \brief Get cached value, refresh if necessary.
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contained no body
     //! \throws HueAPIResponseException when response contains an error
     //! \throws nlohmann::json::parse_error when response could not be parsed
-    nlohmann::json& GetValue();
+    nlohmann::json& getValue();
     //! \brief Get cached value, does not refresh.
-    const nlohmann::json& GetValue() const;
+    const nlohmann::json& getValue() const;
     //! \brief Get duration between refreshes.
-    std::chrono::steady_clock::duration GetRefreshDuration() const;
+    std::chrono::steady_clock::duration getRefreshDuration() const;
 private:
     std::string path;
@@ -34,67 +34,250 @@
 namespace hueplusplus
 {
+//! \brief Class for Groups of lights.
+//!
+//! Provides methods to control groups.
 class Group
 {
 public:
+    //! Creates group with id
+    //! \param id Group id in the bridge
+    //! \param commands HueCommandAPI for requests
+    //! \param refreshDuration Time between refreshing the cached state.
     Group(int id, const HueCommandAPI& commands, std::chrono::steady_clock::duration refreshDuration);
-    virtual ~Group() = default;
+    //! \brief Refreshes internal cached state.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
+    void refresh();
-    void Refresh();
+    //! \name General information
+    ///@{
+    //! \brief Get the group id.
     int getId() const;
+
+    //! \brief Get the group name.
     std::string getName() const;
+
+    //! \brief Get the group type.
+    //!
+    //! The type is specified on creation and cannot be changed.
+    //!
+    //! Possible types:
+    //! \li <code>0</code>: Special group containing all lights, cannot be modified.
+    //! \li <code>Luminaire</code>, <code>Lightsource</code>: Automatically created groups for multisource luminaires.
+    //! \li <code>LightGroup</code>: Standard, user created group, not empty.
+    //! \li <code>Room</code>: User created room, has room type.
+    //! \li <code>Entertainment</code>: User created entertainment setup.
+    //! \li <code>Zone</code>: User created Zone.
     std::string getType() const;
+
+    //! \brief Get lights in the group.
+    //! \returns Ids of the lights in the group.
     std::vector<int> getLightIds() const;
+    //! \brief Set group name.
+    //! \param name New name for the group.
+    //! Must be unique for all groups, otherwise a number is added.
     void setName(const std::string& name);
+    //! \brief Set group lights.
+    //! \param ids New light ids. May or may not be empty depending on type.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     void setLights(const std::vector<int>& ids);
-    // Only for type room
+    //! \brief Get room type, only for type room.
+    //! \returns Room type/class of the group.
     std::string getRoomType() const;
+    //! \brief Set room type, only for type room.
+    //! \param type New room class, case sensitive.
+    //! Only specific values are allowed.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     void setRoomType(const std::string& type);
-    // Only for type luminaire
+    //! \brief Get luminaire model id, only for type luminaire.
+    //! \returns Unique id for the hardware model.
     std::string getModelId() const;
-    // For luminaire or lightsource
+
+    //! \brief Get luminaire model id, only for type luminaire or lightsource.
+    //! \returns Unique id in <code>AA:BB:CC:DD</code> format for luminaire groups
+    //! or <code>AA:BB:CC:DD-XX</code> for Lightsource groups.
     std::string getUniqueId() const;
+    //! \brief Get whether all lights are on.
+    //! \returns true when all lights are on.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     bool getAllOn();
+
+    //! \brief Get whether all lights are on.
+    //! \returns true when all lights are on.
+    //! \note Does not refresh the state.
     bool getAllOn() const;
+
+    //! \brief Get whether any light is on.
+    //! \returns true when any light is on.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     bool getAnyOn();
+
+    //! \brief Get whether any light is on.
+    //! \returns true when any light is on.
+    //! \note Does not refresh the state.
     bool getAnyOn() const;
+    ///@}
+    //! \name Query Action
+    //! The action is the state of one light in the group.
+    //! It can be accessed using these methods.
+    ///@{
+
+    //! \brief Get on state of one light in the group.
+    //! \returns True if the light is on.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     bool getActionOn();
+
+    //! \brief Get on state of one light in the group.
+    //! \returns True if the light is on.
+    //! \note Does not refresh the state.
     bool getActionOn() const;
+
+    //! \brief Get hue and saturation of one light in the group.
+    //! \returns Pair of hue, saturation.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     std::pair<uint16_t, uint8_t> getActionHueSaturation();
+
+    //! \brief Get hue and saturation of one light in the group.
+    //! \returns Pair of hue, saturation.
+    //! \note Does not refresh the state.
     std::pair<uint16_t, uint8_t> getActionHueSaturation() const;
+
+    //! \brief Get brightness of one light in the group.
+    //! \returns Brightness (0-254).
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     unsigned int getActionBrightness();
+
+    //! \brief Get brightness of one light in the group.
+    //! \returns Brightness (0-254).
+    //! \note Does not refresh the state.
     unsigned int getActionBrightness() const;
+
+    //! \brief Get color temperature of one light in the group.
+    //! \returns Color temperature in mired.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     unsigned int getActionColorTemperature();
+
+    //! \brief Get color temperature of one light in the group.
+    //! \returns Color temperature in mired.
+    //! \note Does not refresh the state.
     unsigned int getActionColorTemperature() const;
+
+    //! \brief Get color coordinates of one light in the group.
+    //! \returns Pair of x and y color coordinates.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     std::pair<float, float> getActionColorXY();
+
+    //! \brief Get color coordinates of one light in the group.
+    //! \returns Pair of x and y color coordinates.
+    //! \note Does not refresh the state.
     std::pair<float, float> getActionColorXY() const;
+
+    //! \brief Get color mode of one light in the group.
+    //!
+    //! The color mode is the currently used way to specify the color (hs,ct or xy).
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     std::string getActionColorMode();
+
+    //! \brief Get color mode of one light in the group.
+    //!
+    //! The color mode is the currently used way to specify the color (hs,ct or xy).
+    //! \note Does not refresh the state.
     std::string getActionColorMode() const;
+    ///@}
+
+    //! \name Change lights
+    ///@{
+
+    //! \brief Create a transaction for this group.
+    //!
+    //! The transaction can be used to change more than one value in one request.
+    //!
+    //! Example usage: \code
+    //! group.transaction().setBrightness(240).setColorHue(5000).commit();
+    //! \endcode
     StateTransaction transaction();
+    //! \brief Convenience function to turn lights on.
+    //! \see StateTransaction::setOn
     void setOn(bool on, uint8_t transition = 4);
+    //! \brief Convenience function to set brightness.
+    //! \see StateTransaction::setBrightness
     void setBrightness(uint8_t brightness, uint8_t transition = 4);
+    //! \brief Convenience function to set hue and saturation.
+    //! \see StateTransaction::setColorHue
+    //! \see StateTransaction::setColorSaturation
     void setColorHueSaturation(uint16_t hue, uint8_t saturation, uint8_t transition = 4);
+    //! \brief Convenience function to set color xy.
+    //! \see StateTransaction::setColorXY
     void setColorXY(float x, float y, uint8_t transition = 4);
+    //! \brief Convenience function to set color temperature.
+    //! \see StateTransaction::setColorTemperature
     void setColorTemperature(unsigned int mired, uint8_t transition = 4);
+    //! \brief Convenience function to set color loop.
+    //! \see StateTransaction::setColorLoop
     void setColorLoop(bool on, uint8_t transition = 4);
-    void incrementBrightness(int increment, uint8_t transition = 4);
-    void incrementSaturation(int increment, uint8_t transition = 4);
-    void incrementHue(int increment, uint8_t transition = 4);
-    void incrementColorTemperature(int increment, uint8_t transition = 4);
-    void incrementColorXY(float incX, float incY, uint8_t transition = 4);
+
+    //! \brief Recall scene for the group.
+    //!
+    //! Scenes are saved configurations for the lights in a group.
+    //! \param scene Scene name.
     void setScene(const std::string& scene);
+    ///@}
+
 protected:
-    nlohmann::json SendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo);
+    //! \brief Utility function to send a put request to the group.
+    //!
+    //! \param request The request to send
+    //! \param subPath A path that is appended to the uri, note it should always start with a slash ("/")
+    //! \param fileInfo FileInfo from calling function for exception details.
+    //! \returns The parsed reply
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
+    nlohmann::json sendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo);
 protected:
     int id;
@@ -102,17 +285,54 @@ protected:
     HueCommandAPI commands;
 };
+//! \brief Parameters necessary for creating a new Group.
+//!
+//! Provides static functions for each group type that can be created by the user.
+//! \note These are not all types that Group::getType() can return,
+//! because some types cannot be created manually.
 class CreateGroup
 {
 public:
+    //! \brief Create a LightGroup.
+    //!
+    //! LightGroup is the default type for groups. Empty LightGroups will be deleted.
+    //! \param lights List of light ids, must not be empty.
+    //! \param name Name of the new group, optional.
     static CreateGroup LightGroup(const std::vector<int>& lights, const std::string& name = "");
+    //! \brief Create a Room group.
+    //!
+    //! Rooms can have a room class and can be empty. Every light can only be in one room.
+    //! \param lights List of light ids, may be empty.
+    //! \param name Name of the room, optional.
+    //! \param roomType Class of the room (case sensitive), optional.
+    //! Refer to Hue developer documentation for a list of possible room classes.
     static CreateGroup Room(
         const std::vector<int>& lights, const std::string& name = "", const std::string& roomType = "");
+    //! \brief Create an Entertainment group.
+    //!
+    //! The lights are used in an entertainment setup and can have relative positions.
+    //! The group can be empty.
+    //! \param lights List of light ids, may be empty.
+    //! \param name Name of the group, optional.
     static CreateGroup Entertainment(const std::vector<int>& lights, const std::string& name = "");
+    //! \brief Create a Zone.
+    //!
+    //! Zones can be empty, a light can be in multiple zones.
+    //! \param lights List of light ids, may be empty.
+    //! \param name Name of the Zone, optional.
+    static CreateGroup Zone(const std::vector<int>& lights, const std::string& name = "");
+
+    //! \brief Get request to create the group.
+    //! \returns JSON request for a POST to create the new group
     nlohmann::json getRequest() const;
 protected:
+    //! \brief Protected constructor, should not be called directly.
+    //! \param lights List of light ids for the group.
+    //! \param name Name of the group, empty for default name.
+    //! \param type Type of the group, empty for default type.
+    //! \param roomType Room class if type is room, empty for default class or if type is not room.
     CreateGroup(
         const std::vector<int>& lights, const std::string& name, const std::string& type, const std::string& roomType);
@@ -112,7 +112,9 @@ private:
     std::shared_ptr<const IHttpHandler> http_handler;
 };
-//! Hue class
+//! \brief Hue class for a bridge.
+//!
+//! This is the main class used to interact with the Hue bridge.
 class Hue
 {
     friend class HueFinder;
@@ -123,11 +125,15 @@ public:
     //! \param ip IP address in dotted decimal notation like "192.168.2.1"
     //! \param port Port of the hue bridge
     //! \param username String that specifies the username that is used to control
-    //! the bridge. This needs to be acquired in \ref requestUsername
+    //! the bridge. Can be left empty and acquired in \ref requestUsername.
     //! \param handler HttpHandler for communication with the bridge
+    //! \param refreshDuration Time between refreshing the cached state.
     Hue(const std::string& ip, const int port, const std::string& username, std::shared_ptr<const IHttpHandler> handler,
         std::chrono::steady_clock::duration refreshDuration = std::chrono::seconds(10));
+    //! \name Configuration
+    ///@{
+
     //! \brief Function to get the ip address of the hue bridge
     //!
     //! \return string containing ip
@@ -165,6 +171,16 @@ public:
     //! "192.168.2.1:8080"
     void setPort(const int port);
+    //! \brief Function that sets the HttpHandler and updates the HueCommandAPI.
+    //!
+    //! The HttpHandler and HueCommandAPI are used for bridge communication
+    //! \param handler a HttpHandler of type \ref IHttpHandler
+    void setHttpHandler(std::shared_ptr<const IHttpHandler> handler);
+
+    ///@}
+    //! \name Lights
+    ///@{
+
     //! \brief Function that returns a \ref HueLight of specified id
     //!
     //! \param id Integer that specifies the ID of a Hue light
@@ -186,11 +202,6 @@ public:
     //! \throws nlohmann::json::parse_error when response could not be parsed
     bool removeLight(int id);
-    //! \brief Function that returns all light types that are associated with this bridge
-    //!
-    //! \return A map mapping light id's to light types for every light
-    // const std::map<uint8_t, ColorType>& getAllLightTypes();
-
     //! \brief Function that returns all lights that are associated with this
     //! bridge
     //!
@@ -202,8 +213,6 @@ public:
     std::vector<std::reference_wrapper<HueLight>> getAllLights();
     //! \brief Function that tells whether a given light id represents an existing light
-    //!
-    //! Calls refreshState to update the local bridge state
     //! \param id Id of a light to check for existance
     //! \return Bool that is true when a light with the given id exists and false when not
     //! \throws std::system_error when system or socket operations fail
@@ -221,15 +230,67 @@ public:
     //! when not
     bool lightExists(int id) const;
+    ///@}
+    //! \name Groups
+    ///@{
+
+    //! \brief Get all groups that exist on this bridge.
+    //! \return A vector of references to every Group.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contains no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     std::vector<std::reference_wrapper<Group>> getAllGroups();
+    //! \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 
+    //! and is not visible to getAllGroups().
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when id does not exist
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     Group& getGroup(int id);
+
+    //! \brief Remove a group from the bridge.
+    //! \param id ID of the group.
+    //! \returns true on success.
+    //! \brief Remove a group from the bridge.
+    //! \param id ID of the group.
+    //! \returns true on success.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contains no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     bool removeGroup(int id);
+
+    //! \brief Checks whether a group exists.
+    //! \param id ID of the group.
+    //! \returns true when the group exists.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contains no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     bool groupExists(int id);
+
+    //! \brief Checks whether a group exists.
+    //! \param id ID of the group.
+    //! \returns true when the group exists.
+    //! \note Does not refresh the cached state.
     bool groupExists(int id) const;
+    //! \brief Create a new group.
+    //! \param params CreateGroup parameters for the new group.
+    //! \returns The new group id or 0 if failed.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contains no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     int createGroup(const CreateGroup& params);
+    ///@}
+
     //! \brief Const function that returns the picture name of a given light id
     //!
     //! \note This will not update the local state of the bridge.
@@ -249,16 +310,6 @@ public:
     //! string
     std::string getPictureOfModel(const std::string& model_id) const;
-    //! \brief Function that sets the HttpHandler and updates the HueCommandAPI.
-    //!
-    //! The HttpHandler and HueCommandAPI are used for bridge communication
-    //! \param handler a HttpHandler of type \ref IHttpHandler
-    void setHttpHandler(std::shared_ptr<const IHttpHandler> handler)
-    {
-        http_handler = std::move(handler);
-        commands = HueCommandAPI(ip, port, username, http_handler);
-    }
-
 private:
     std::string ip; //!< IP-Address of the hue bridge in dotted decimal notation
                     //!< like "192.168.2.1"
@@ -65,48 +65,59 @@ public:
     //! This function will block until at least \ref minDelay has passed to any previous request
     //! \param path API request path (appended after /api/{username})
     //! \param request Request to the api, may be empty
+    //! \param fileInfo File information for thrown exceptions.
     //! \returns The return value of the underlying \ref IHttpHandler::PUTJson call
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contains no body
     //! \throws HueAPIResponseException when response contains an error
-    nlohmann::json PUTRequest(const std::string& path, const nlohmann::json& request) const;
     nlohmann::json PUTRequest(const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const;
+    //! \overload
+    nlohmann::json PUTRequest(const std::string& path, const nlohmann::json& request) const;
     //! \brief Sends a HTTP GET request to the bridge and returns the response
     //!
     //! This function will block until at least \ref minDelay has passed to any previous request
     //! \param path API request path (appended after /api/{username})
     //! \param request Request to the api, may be empty
+    //! \param fileInfo File information for thrown exceptions.
     //! \returns The return value of the underlying \ref IHttpHandler::GETJson call
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contains no body
     //! \throws HueAPIResponseException when response contains an error
-    nlohmann::json GETRequest(const std::string& path, const nlohmann::json& request) const;
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     nlohmann::json GETRequest(const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const;
+    //! \overload
+    nlohmann::json GETRequest(const std::string& path, const nlohmann::json& request) const;
     //! \brief Sends a HTTP DELETE request to the bridge and returns the response
     //!
     //! This function will block until at least \ref minDelay has passed to any previous request
     //! \param path API request path (appended after /api/{username})
     //! \param request Request to the api, may be empty
+    //! \param fileInfo File information for thrown exceptions.
     //! \returns The return value of the underlying \ref IHttpHandler::DELETEJson call
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contains no body
     //! \throws HueAPIResponseException when response contains an error
-    nlohmann::json DELETERequest(const std::string& path, const nlohmann::json& request) const;
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     nlohmann::json DELETERequest(const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const;
+    //! \overload
+    nlohmann::json DELETERequest(const std::string& path, const nlohmann::json& request) const;
     //! \brief Sends a HTTP POST request to the bridge and returns the response
     //!
     //! This function will block until at least \ref minDelay has passed to any previous request
     //! \param path API request path (appended after /api/{username})
     //! \param request Request to the api, may be empty
+    //! \param fileInfo File information for thrown exceptions.
     //! \returns The return value of the underlying \ref IHttpHandler::POSTJson call
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contains no body
     //! \throws HueAPIResponseException when response contains an error
-    nlohmann::json POSTRequest(const std::string& path, const nlohmann::json& request) const;
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     nlohmann::json POSTRequest(const std::string& path, const nlohmann::json& request, FileInfo fileInfo) const;
+    //! \overload
+    nlohmann::json POSTRequest(const std::string& path, const nlohmann::json& request) const;
 private:
     struct TimeoutData
@@ -30,7 +30,7 @@
 namespace hueplusplus
 {
-//! \brief Contains information about error location, use CURRENT_FILE_INFO to create
+//! \brief Contains information about error location, use \ref CURRENT_FILE_INFO to create
 struct FileInfo
 {
     //! \brief Current file name from __FILE__. Empty if unknown
@@ -22,6 +22,8 @@
 #include "HueException.h"
+//! \def CURRENT_FILE_INFO
+//! \brief Creates the FileInfo for the current line.
 #ifndef CURRENT_FILE_INFO
 #define CURRENT_FILE_INFO (::hueplusplus::FileInfo{__FILE__, __LINE__, __func__})
 #endif
 \ No newline at end of file
@@ -92,9 +92,9 @@ enum class ColorType
     GAMUT_C_TEMPERATURE
 };
+//! \brief Class for Hue Light fixtures
 //!
-//! Class for Hue Light fixtures
-//!
+//! Provides methods to query and control lights.
 class HueLight
 {
     friend class Hue;
@@ -109,40 +109,8 @@ public:
     //! \brief std dtor
     ~HueLight() = default;
-    //! \brief Function that turns the light on.
-    //!
-    //! \param transition Optional parameter to set the transition from current state to new, standard is 4 = 400ms
-    //! \return true on success
-    //! \throws std::system_error when system or socket operations fail
-    //! \throws HueException when response contained no body
-    //! \throws HueAPIResponseException when response contains an error
-    //! \throws nlohmann::json::parse_error when response could not be parsed
-    virtual bool On(uint8_t transition = 4);
-
-    //! \brief Function that turns the light off.
-    //!
-    //! \param transition Optional parameter to set the transition from current state to new, standard is 4 = 400ms
-    //! \return Bool that is true on success
-    //! \throws std::system_error when system or socket operations fail
-    //! \throws HueException when response contained no body
-    //! \throws HueAPIResponseException when response contains an error
-    //! \throws nlohmann::json::parse_error when response could not be parsed
-    virtual bool Off(uint8_t transition = 4);
-
-    //! \brief Function to check whether a light is on or off
-    //!
-    //! \return Bool that is true, when the light is on and false, when off
-    //! \throws std::system_error when system or socket operations fail
-    //! \throws HueException when response contained no body
-    //! \throws HueAPIResponseException when response contains an error
-    //! \throws nlohmann::json::parse_error when response could not be parsed
-    virtual bool isOn();
-
-    //! \brief Const function to check whether a light is on or off
-    //!
-    //! \note This will not refresh the light state
-    //! \return Bool that is true, when the light is on and false, when off
-    virtual bool isOn() const;
+    //! \name General information
+    ///@{
     //! \brief Const function that returns the id of this light
     //!
@@ -169,6 +137,15 @@ public:
     //! \return String containig the name of the light
     virtual std::string getName() const;
+    //! \brief Function that sets the name of the light
+    //!
+    //! \return Bool that is true on success
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
+    virtual bool setName(const std::string& name);
+
     //! \brief Const function that returns the modelid of the light
     //!
     //! \return String conatining the modelid
@@ -213,14 +190,44 @@ public:
     //! \return String containing the software version
     virtual std::string getSwVersion() const;
-    //! \brief Function that sets the name of the light
+    ///@}
+    //! \name Light state
+    ///@{
+
+    //! \brief Function that turns the light on.
     //!
+    //! \param transition Optional parameter to set the transition from current state to new, standard is 4 = 400ms
+    //! \return true on success
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
+    virtual bool On(uint8_t transition = 4);
+
+    //! \brief Function that turns the light off.
+    //!
+    //! \param transition Optional parameter to set the transition from current state to new, standard is 4 = 400ms
     //! \return Bool that is true on success
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contained no body
     //! \throws HueAPIResponseException when response contains an error
     //! \throws nlohmann::json::parse_error when response could not be parsed
-    virtual bool setName(const std::string& name);
+    virtual bool Off(uint8_t transition = 4);
+
+    //! \brief Function to check whether a light is on or off
+    //!
+    //! \return Bool that is true, when the light is on and false, when off
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
+    virtual bool isOn();
+
+    //! \brief Const function to check whether a light is on or off
+    //!
+    //! \note This will not refresh the light state
+    //! \return Bool that is true, when the light is on and false, when off
+    virtual bool isOn() const;
     //! \brief Const function that returns the color type of the light.
     //!
@@ -677,8 +684,25 @@ public:
         return false;
     };
+    //! \brief Create a transaction for this light.
+    //!
+    //! The transaction can be used to change more than one value in one request.
+    //! Only use the functions supported by the current light type.
+    //!
+    //! Example usage: \code
+    //! light.transaction().setBrightness(240).setColorHue(5000).commit();
+    //! \endcode
     virtual StateTransaction transaction();
+    ///@}
+
+    //! \brief Refreshes internal cached state.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contained no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
+    virtual void refresh();
+
 protected:
     //! \brief Protected ctor that is used by \ref Hue class.
     //!
@@ -696,6 +720,8 @@ protected:
     //! \param brightnessStrategy Strategy for brightness. May be nullptr.
     //! \param colorTempStrategy Strategy for color temperature. May be nullptr.
     //! \param colorHueStrategy Strategy for color hue/saturation. May be nullptr.
+    //! \param refreshDuration Time between refreshing the cached state.
+    //! Can be 0 to always refresh, or steady_clock::duration::max() to never refresh.
     //! \throws std::system_error when system or socket operations fail
     //! \throws HueException when response contained no body
     //! \throws HueAPIResponseException when response contains an error
@@ -742,7 +768,6 @@ protected:
     //! \brief Utility function to send a put request to the light.
     //!
-    //! \throws nlohmann::json::parse_error if the reply could not be parsed
     //! \param request A nlohmann::json aka the request to send
     //! \param subPath A path that is appended to the uri, note it should always start with a slash ("/")
     //! \param fileInfo FileInfo from calling function for exception details.
@@ -751,11 +776,11 @@ protected:
     //! \throws HueException when response contained no body
     //! \throws HueAPIResponseException when response contains an error
     //! \throws nlohmann::json::parse_error when response could not be parsed
-    virtual nlohmann::json SendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo);
+    virtual nlohmann::json sendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo);
 protected:
     int id; //!< holds the id of the light
-    APICache state; //!< holds the current state of the light updated by \ref refreshState
+    APICache state; //!< holds the current state of the light
     ColorType colorType; //!< holds the \ref ColorType of the light
     std::shared_ptr<const BrightnessStrategy>
@@ -31,31 +31,120 @@
 namespace hueplusplus
 {
+//! \brief Transaction class which can be used for either light or group state.
+//!
+//! This is intended to be used in-line, all calls are chained until a \ref commit() call.
+//! \code
+//! light.transaction().setOn(true).setBrightness(29).setColorHue(3000).setColorSaturation(128).commit();
+//! \endcode
 class StateTransaction
 {
 public:
+    //! \brief Creates a StateTransaction to a group or light state
+    //! \param commands HueCommandAPI for making requests
+    //! \param path Path to which the final PUT request is made (without username)
+    //! \param currentState JSON object with the current state to check whether changes are needed.
+    //! Pass an empty object to always include all requests (for groups, because individual lights might be different).
     StateTransaction(const HueCommandAPI& commands, const std::string& path, const nlohmann::json& currentState);
+    //! \brief Deleted copy constructor, do not store StateTransaction in a variable.
     StateTransaction(const StateTransaction&) = delete;
     StateTransaction(StateTransaction&&) = default;
+    //! \brief Commit transaction and make request.
+    //! \returns true on success or when no change was requested.
+    //! \note After changing the state of a HueLight or Group, 
+    //! refresh() must be called if the updated values are needed immediately.
+    //! \throws std::system_error when system or socket operations fail
+    //! \throws HueException when response contains no body
+    //! \throws HueAPIResponseException when response contains an error
+    //! \throws nlohmann::json::parse_error when response could not be parsed
     bool commit() &&;
+    //! \brief Turn light on or off.
+    //! \param on true for on, false for off
+    //! \returns This transaction for chaining calls
     StateTransaction&& setOn(bool on) &&;
+    //! \brief Set light brightness.
+    //! \param brightness Brightness from 0 = off to 254 = fully lit.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have brightness control.
+    //! \note Brightness 0 will also turn off the light if nothing else is specified,
+    //! any other value will also turn on the light.
     StateTransaction&& setBrightness(uint8_t brightness) &&;
+    //! \brief Set light hue.
+    //! \param hue Color hue from 0 to 65535
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
+    //! \note Will also turn on the light if nothing else is specified
     StateTransaction&& setColorHue(uint16_t hue) &&;
+    //! \brief Set light saturation.
+    //! \param saturation Color saturation from 0 to 254
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
+    //! \note Will also turn on the light if nothing else is specified
     StateTransaction&& setColorSaturation(uint8_t saturation) &&;
+    //! \brief Set light color in xy space.
+    //! \param x x coordinate in CIE color space
+    //! \param y y coordinate in CIE color space
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
+    //! \note Will also turn on the light if nothing else is specified
     StateTransaction&& setColorXY(float x, float y) &&;
+    //! \brief Set light color temperature.
+    //! \param mired Color temperature in mired from 153 to 500
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have color temperature control.
+    //! \note Will also turn on the light if nothing else is specified
     StateTransaction&& setColorTemperature(unsigned int mired) &&;
+    //! \brief Enables or disables color loop.
+    //! \param on true to enable, false to disable color loop.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
+    //! \note Will also turn on the light if nothing else is specified
     StateTransaction&& setColorLoop(bool on) &&;
+    //! \brief Increment/Decrement brightness.
+    //! \param increment Brightness change from -254 to 254.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have brightness control.
     StateTransaction&& incrementBrightness(int increment) &&;
+    //! \brief Increment/Decrement saturaction.
+    //! \param increment Saturation change from -254 to 254.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
     StateTransaction&& incrementSaturation(int increment) &&;
+    //! \brief Increment/Decrement hue.
+    //! \param increment Hue change from -65535 to 65535.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
     StateTransaction&& incrementHue(int increment) &&;
+    //! \brief Increment/Decrement color temperature.
+    //! \param increment Color temperature change in mired from -65535 to 65535.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have color temperature control.
     StateTransaction&& incrementColorTemperature(int increment) &&;
+    //! \brief Increment/Decrement color xy.
+    //! \param xInc x color coordinate change from -0.5 to 0.5.
+    //! \param yInc y color coordinate change from -0.5 to 0.5.
+    //! \returns This transaction for chaining calls
+    //! \note If this transaction is for a light, the light needs to have rgb color control.
     StateTransaction&& incrementColorXY(float xInc, float yInc) &&;
+    //! \brief Set transition time for the request.
+    //! \param transition Transition time in 100ms, default for any request is 400ms.
+    //! \returns This transaction for chaining calls
+    //! \note The transition only applies to the current request. 
+    //! A request without any changes only containing a transition is pointless and is not sent.
     StateTransaction&& setTransition(uint16_t transition) &&;
+    //! \brief Trigger an alert.
+    //!
+    //! The light performs one breathe cycle.
+    //! \returns This transaction for chaining calls
     StateTransaction&& alert() &&;
+    //! \brief Trigger a long alert (15s).
+    //! \returns This transaction for chaining calls
     StateTransaction&& longAlert() &&;
+    //! \brief Stop an ongoing long alert.
+    //! \returns This transaction for chaining calls
     StateTransaction&& stopAlert() &&;
 protected:
@@ -28,13 +28,13 @@ hueplusplus::APICache::APICache(
     : path(path), commands(commands), refreshDuration(refresh), lastRefresh(std::chrono::steady_clock::duration::zero())
 {}
-void hueplusplus::APICache::Refresh()
+void hueplusplus::APICache::refresh()
 {
     value = commands.GETRequest(path, nlohmann::json::object(), CURRENT_FILE_INFO);
     lastRefresh = std::chrono::steady_clock::now();
 }
-nlohmann::json& hueplusplus::APICache::GetValue()
+nlohmann::json& hueplusplus::APICache::getValue()
 {
     using clock = std::chrono::steady_clock;
     // Explicitly check for zero in case refreshDuration is duration::max()
@@ -42,7 +42,7 @@ nlohmann::json&amp; hueplusplus::APICache::GetValue()
     if (lastRefresh.time_since_epoch().count() == 0 || refreshDuration.count() < 0)
     {
         // No value set yet
-        Refresh();
+        refresh();
     }
     // Check if nextRefresh would overflow (assumes lastRefresh is not negative, which it should not be).
     // If addition would overflow, do not refresh
@@ -51,18 +51,18 @@ nlohmann::json&amp; hueplusplus::APICache::GetValue()
         clock::time_point nextRefresh = lastRefresh + refreshDuration;
         if (clock::now() >= nextRefresh)
         {
-            Refresh();
+            refresh();
         }
     }
     return value;
 }
-const nlohmann::json& hueplusplus::APICache::GetValue() const
+const nlohmann::json& hueplusplus::APICache::getValue() const
 {
     return value;
 }
-std::chrono::steady_clock::duration hueplusplus::APICache::GetRefreshDuration() const
+std::chrono::steady_clock::duration hueplusplus::APICache::getRefreshDuration() const
 {
     return refreshDuration;
 }
@@ -33,7 +33,7 @@ namespace hueplusplus
 bool ExtendedColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -116,7 +116,7 @@ bool ExtendedColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, Hue
 bool ExtendedColorHueStrategy::alertXY(float x, float y, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -199,7 +199,7 @@ bool ExtendedColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
 bool ExtendedColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -36,7 +36,7 @@ bool ExtendedColorTemperatureStrategy::setColorTemperature(
     unsigned int mired, uint8_t transition, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     nlohmann::json request = nlohmann::json::object();
     if (transition != 4)
     {
@@ -65,7 +65,7 @@ bool ExtendedColorTemperatureStrategy::setColorTemperature(
         return true;
     }
-    nlohmann::json reply = light.SendPutRequest(request, "/state", CURRENT_FILE_INFO);
+    nlohmann::json reply = light.sendPutRequest(request, "/state", CURRENT_FILE_INFO);
     // Check whether request was successful
     return utils::validateReplyForLight(request, reply, light.id);
@@ -74,7 +74,7 @@ bool ExtendedColorTemperatureStrategy::setColorTemperature(
 bool ExtendedColorTemperatureStrategy::alertTemperature(unsigned int mired, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -7,12 +7,12 @@ namespace hueplusplus
 Group::Group(int id, const HueCommandAPI& commands, std::chrono::steady_clock::duration refreshDuration)
     : id(id), state("/groups/" + std::to_string(id), commands, refreshDuration), commands(commands)
 {
-    state.Refresh();
+    state.refresh();
 }
-void Group::Refresh()
+void Group::refresh()
 {
-    state.Refresh();
+    state.refresh();
 }
 int Group::getId() const
@@ -22,17 +22,17 @@ int Group::getId() const
 std::string Group::getName() const
 {
-    return state.GetValue().at("name").get<std::string>();
+    return state.getValue().at("name").get<std::string>();
 }
 std::string Group::getType() const
 {
-    return state.GetValue().at("type").get<std::string>();
+    return state.getValue().at("type").get<std::string>();
 }
 std::vector<int> Group::getLightIds() const
 {
-    const nlohmann::json& lights = state.GetValue().at("lights");
+    const nlohmann::json& lights = state.getValue().at("lights");
     std::vector<int> ids;
     ids.reserve(lights.size());
     for (const nlohmann::json& id : lights)
@@ -45,8 +45,8 @@ std::vector&lt;int&gt; Group::getLightIds() const
 void Group::setName(const std::string& name)
 {
     nlohmann::json request = {{"name", name}};
-    SendPutRequest(request, "", CURRENT_FILE_INFO);
-    Refresh();
+    sendPutRequest(request, "", CURRENT_FILE_INFO);
+    refresh();
 }
 void Group::setLights(const std::vector<int>& ids)
@@ -56,86 +56,86 @@ void Group::setLights(const std::vector&lt;int&gt;&amp; ids)
     {
         lights.push_back(std::to_string(id));
     }
-    SendPutRequest({{"lights", lights}}, "", CURRENT_FILE_INFO);
-    Refresh();
+    sendPutRequest({{"lights", lights}}, "", CURRENT_FILE_INFO);
+    refresh();
 }
 bool Group::getAllOn()
 {
-    return state.GetValue().at("state").at("all_on").get<bool>();
+    return state.getValue().at("state").at("all_on").get<bool>();
 }
 bool Group::getAllOn() const
 {
-    return state.GetValue().at("state").at("all_on").get<bool>();
+    return state.getValue().at("state").at("all_on").get<bool>();
 }
 bool Group::getAnyOn()
 {
-    return state.GetValue().at("state").at("any_on").get<bool>();
+    return state.getValue().at("state").at("any_on").get<bool>();
 }
 bool Group::getAnyOn() const
 {
-    return state.GetValue().at("state").at("any_on").get<bool>();
+    return state.getValue().at("state").at("any_on").get<bool>();
 }
 bool Group::getActionOn()
 {
-    return state.GetValue().at("action").at("on").get<bool>();
+    return state.getValue().at("action").at("on").get<bool>();
 }
 bool Group::getActionOn() const
 {
-    return state.GetValue().at("action").at("on").get<bool>();
+    return state.getValue().at("action").at("on").get<bool>();
 }
 std::pair<uint16_t, uint8_t> Group::getActionHueSaturation()
 {
-    const nlohmann::json& action = state.GetValue().at("action");
+    const nlohmann::json& action = state.getValue().at("action");
     return std::make_pair(action.at("hue").get<int>(), action.at("sat").get<int>());
 }
 std::pair<uint16_t, uint8_t> Group::getActionHueSaturation() const
 {
-    const nlohmann::json& action = state.GetValue().at("action");
+    const nlohmann::json& action = state.getValue().at("action");
     return std::make_pair(action.at("hue").get<int>(), action.at("sat").get<int>());
 }
 unsigned int Group::getActionBrightness()
 {
-    return state.GetValue().at("action").at("bri").get<int>();
+    return state.getValue().at("action").at("bri").get<int>();
 }
 unsigned int Group::getActionBrightness() const
 {
-    return state.GetValue().at("action").at("bri").get<int>();
+    return state.getValue().at("action").at("bri").get<int>();
 }
 unsigned int Group::getActionColorTemperature()
 {
-    return state.GetValue().at("action").at("ct").get<int>();
+    return state.getValue().at("action").at("ct").get<int>();
 }
 unsigned int Group::getActionColorTemperature() const
 {
-    return state.GetValue().at("action").at("ct").get<int>();
+    return state.getValue().at("action").at("ct").get<int>();
 }
 std::pair<float, float> Group::getActionColorXY()
 {
-    const nlohmann::json& xy = state.GetValue().at("action").at("xy");
+    const nlohmann::json& xy = state.getValue().at("action").at("xy");
     return std::pair<float, float>(xy[0].get<float>(), xy[1].get<float>());
 }
 std::pair<float, float> Group::getActionColorXY() const
 {
-    const nlohmann::json& xy = state.GetValue().at("action").at("xy");
+    const nlohmann::json& xy = state.getValue().at("action").at("xy");
     return std::pair<float, float>(xy[0].get<float>(), xy[1].get<float>());
 }
 std::string Group::getActionColorMode()
 {
-    return state.GetValue().at("action").at("colormode").get<std::string>();
+    return state.getValue().at("action").at("colormode").get<std::string>();
 }
 std::string Group::getActionColorMode() const
 {
-    return state.GetValue().at("action").at("colormode").get<std::string>();
+    return state.getValue().at("action").at("colormode").get<std::string>();
 }
 StateTransaction Group::transaction()
@@ -174,60 +174,35 @@ void Group::setColorLoop(bool on, uint8_t transition)
     transaction().setColorLoop(on).setTransition(transition);
 }
-void Group::incrementBrightness(int increment, uint8_t transition)
-{
-    transaction().incrementBrightness(increment).setTransition(transition).commit();
-}
-
-void Group::incrementSaturation(int increment, uint8_t transition)
-{
-    transaction().incrementSaturation(increment).setTransition(transition).commit();
-}
-
-void Group::incrementHue(int increment, uint8_t transition)
-{
-    transaction().incrementHue(increment).setTransition(transition).commit();
-}
-
-void Group::incrementColorTemperature(int increment, uint8_t transition)
-{
-    transaction().incrementColorTemperature(increment).setTransition(transition).commit();
-}
-
-void Group::incrementColorXY(float incX, float incY, uint8_t transition)
-{
-    transaction().incrementColorXY(incX, incY).setTransition(transition).commit();
-}
-
 void Group::setScene(const std::string& scene)
 {
-    SendPutRequest({{"scene", scene}}, "/action", CURRENT_FILE_INFO);
+    sendPutRequest({{"scene", scene}}, "/action", CURRENT_FILE_INFO);
 }
-nlohmann::json Group::SendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo)
+nlohmann::json Group::sendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo)
 {
     return commands.PUTRequest("/groups/" + std::to_string(id) + subPath, request, std::move(fileInfo));
 }
 std::string Group::getRoomType() const
 {
-    return state.GetValue().at("class").get<std::string>();
+    return state.getValue().at("class").get<std::string>();
 }
 void Group::setRoomType(const std::string& type)
 {
-    SendPutRequest({{"class", type}}, "", CURRENT_FILE_INFO);
-    Refresh();
+    sendPutRequest({{"class", type}}, "", CURRENT_FILE_INFO);
+    refresh();
 }
 std::string Group::getModelId() const
 {
-    return state.GetValue().at("modelid").get<std::string>();
+    return state.getValue().at("modelid").get<std::string>();
 }
 std::string Group::getUniqueId() const
 {
-    return state.GetValue().at("uniqueid").get<std::string>();
+    return state.getValue().at("uniqueid").get<std::string>();
 }
 CreateGroup CreateGroup::LightGroup(const std::vector<int>& lights, const std::string& name)
@@ -245,6 +220,11 @@ CreateGroup CreateGroup::Entertainment(const std::vector&lt;int&gt;&amp; lights, const std
     return CreateGroup(lights, name, "Entertainment", "");
 }
+CreateGroup CreateGroup::Zone(const std::vector<int>& lights, const std::string& name)
+{
+    return CreateGroup(lights, name, "Zone", "");
+}
+
 nlohmann::json CreateGroup::getRequest() const
 {
     nlohmann::json lightStrings = nlohmann::json::array();
@@ -190,7 +190,7 @@ std::string Hue::requestUsername()
                 username = jsonUser.get<std::string>();
                 // Update commands with new username and ip
                 commands = HueCommandAPI(ip, port, username, http_handler);
-                stateCache = APICache("", commands, stateCache.GetRefreshDuration());
+                stateCache = APICache("", commands, stateCache.getRefreshDuration());
                 std::cout << "Success! Link button was pressed!\n";
                 std::cout << "Username is \"" << username << "\"\n";
                 break;
@@ -230,10 +230,10 @@ HueLight&amp; Hue::getLight(int id)
     auto pos = lights.find(id);
     if (pos != lights.end())
     {
-        pos->second.state.Refresh();
+        pos->second.state.refresh();
         return pos->second;
     }
-    const nlohmann::json& lightsCache = stateCache.GetValue()["lights"];
+    const nlohmann::json& lightsCache = stateCache.getValue()["lights"];
     if (!lightsCache.count(std::to_string(id)))
     {
         std::cerr << "Error in Hue getLight(): light with id " << id << " is not valid\n";
@@ -261,7 +261,7 @@ bool Hue::removeLight(int id)
 std::vector<std::reference_wrapper<HueLight>> Hue::getAllLights()
 {
     // No reference because getLight may invalidate it
-    nlohmann::json lightsState = stateCache.GetValue()["lights"];
+    nlohmann::json lightsState = stateCache.getValue()["lights"];
     for (auto it = lightsState.begin(); it != lightsState.end(); ++it)
     {
         getLight(std::stoi(it.key()));
@@ -276,7 +276,7 @@ std::vector&lt;std::reference_wrapper&lt;HueLight&gt;&gt; Hue::getAllLights()
 std::vector<std::reference_wrapper<Group>> Hue::getAllGroups()
 {
-    nlohmann::json groupsState = stateCache.GetValue().at("groups");
+    nlohmann::json groupsState = stateCache.getValue().at("groups");
     for (auto it = groupsState.begin(); it != groupsState.end(); ++it)
     {
         getGroup(std::stoi(it.key()));
@@ -295,16 +295,16 @@ Group&amp; Hue::getGroup(int id)
     auto pos = groups.find(id);
     if (pos != groups.end())
     {
-        pos->second.Refresh();
+        pos->second.refresh();
         return pos->second;
     }
-    const nlohmann::json& groupsCache = stateCache.GetValue()["groups"];
+    const nlohmann::json& groupsCache = stateCache.getValue()["groups"];
     if (!groupsCache.count(std::to_string(id)))
     {
         std::cerr << "Error in Hue getGroup(): group with id " << id << " is not valid\n";
         throw HueException(CURRENT_FILE_INFO, "Group id is not valid");
     }
-    return groups.emplace(id, Group(id, commands, stateCache.GetRefreshDuration())).first->second;
+    return groups.emplace(id, Group(id, commands, stateCache.getRefreshDuration())).first->second;
 }
 bool Hue::removeGroup(int id)
@@ -326,7 +326,7 @@ bool Hue::groupExists(int id)
     {
         return true;
     }
-    if (stateCache.GetValue()["groups"].count(std::to_string(id)))
+    if (stateCache.getValue()["groups"].count(std::to_string(id)))
     {
         return true;
     }
@@ -340,7 +340,7 @@ bool Hue::groupExists(int id) const
     {
         return true;
     }
-    if (stateCache.GetValue()["groups"].count(std::to_string(id)))
+    if (stateCache.getValue()["groups"].count(std::to_string(id)))
     {
         return true;
     }
@@ -365,7 +365,7 @@ bool Hue::lightExists(int id)
     {
         return true;
     }
-    if (stateCache.GetValue()["lights"].count(std::to_string(id)))
+    if (stateCache.getValue()["lights"].count(std::to_string(id)))
     {
         return true;
     }
@@ -379,7 +379,7 @@ bool Hue::lightExists(int id) const
     {
         return true;
     }
-    if (stateCache.GetValue()["lights"].count(std::to_string(id)))
+    if (stateCache.getValue()["lights"].count(std::to_string(id)))
     {
         return true;
     }
@@ -520,4 +520,11 @@ std::string Hue::getPictureOfModel(const std::string&amp; model_id) const
     }
     return ret;
 }
+
+void Hue::setHttpHandler(std::shared_ptr<const IHttpHandler> handler)
+{
+    http_handler = handler;
+    commands = HueCommandAPI(ip, port, username, handler);
+    stateCache = APICache("", commands, stateCache.getRefreshDuration());
+}
 } // namespace hueplusplus
@@ -30,42 +30,42 @@ namespace hueplusplus
 {
 namespace
 {
-const std::set<std::string> getGamutBTypes()
+const std::set<std::string>& getGamutBTypes()
 {
     static const std::set<std::string> c_EXTENDEDCOLORLIGHT_GAMUTB_TYPES
         = {"LCT001", "LCT002", "LCT003", "LCT007", "LLM001"};
     return c_EXTENDEDCOLORLIGHT_GAMUTB_TYPES;
 };
-const std::set<std::string> getGamutCTypes()
+const std::set<std::string>& getGamutCTypes()
 {
     static const std::set<std::string> c_EXTENDEDCOLORLIGHT_GAMUTC_TYPES
         = {"LCT010", "LCT011", "LCT012", "LCT014", "LCT015", "LCT016", "LLC020", "LST002"};
     return c_EXTENDEDCOLORLIGHT_GAMUTC_TYPES;
 }
-const std::set<std::string> getGamutATypes()
+const std::set<std::string>& getGamutATypes()
 {
     static const std::set<std::string> c_EXTENDEDCOLORLIGHT_GAMUTA_TYPES
         = {"LST001", "LLC005", "LLC006", "LLC007", "LLC010", "LLC011", "LLC012", "LLC013", "LLC014"};
     return c_EXTENDEDCOLORLIGHT_GAMUTA_TYPES;
 }
-const std::set<std::string> getNoColorTypes()
+const std::set<std::string>& getNoColorTypes()
 {
     static const std::set<std::string> c_DIMMABLELIGHT_NO_COLOR_TYPES
         = {"LWB004", "LWB006", "LWB007", "LWB010", "LWB014", "LDF001", "LDF002", "LDD001", "LDD002", "MWM001"};
     return c_DIMMABLELIGHT_NO_COLOR_TYPES;
 }
-const std::set<std::string> getNonDimmableTypes()
+const std::set<std::string>& getNonDimmableTypes()
 {
     static const std::set<std::string> c_NON_DIMMABLE_TYPES
         = {"Plug 01"};
     return c_NON_DIMMABLE_TYPES;
 }
-const std::set<std::string> getTemperatureLightTypes()
+const std::set<std::string>& getTemperatureLightTypes()
 {
     static const std::set<std::string> c_TEMPERATURELIGHT_TYPES
         = {"LLM010", "LLM011", "LLM012", "LTW001", "LTW004", "LTW010", "LTW011", "LTW012", "LTW013", "LTW014", "LTW015",
@@ -44,12 +44,12 @@ bool HueLight::Off(uint8_t transition)
 bool HueLight::isOn()
 {
-    return state.GetValue().at("state").at("on").get<bool>();
+    return state.getValue().at("state").at("on").get<bool>();
 }
 bool HueLight::isOn() const
 {
-    return state.GetValue().at("state").at("on").get<bool>();
+    return state.getValue().at("state").at("on").get<bool>();
 }
 int HueLight::getId() const
@@ -59,60 +59,60 @@ int HueLight::getId() const
 std::string HueLight::getType() const
 {
-    return state.GetValue()["type"].get<std::string>();
+    return state.getValue()["type"].get<std::string>();
 }
 std::string HueLight::getName()
 {
-    return state.GetValue()["name"].get<std::string>();
+    return state.getValue()["name"].get<std::string>();
 }
 std::string HueLight::getName() const
 {
-    return state.GetValue()["name"].get<std::string>();
+    return state.getValue()["name"].get<std::string>();
 }
 std::string HueLight::getModelId() const
 {
-    return state.GetValue()["modelid"].get<std::string>();
+    return state.getValue()["modelid"].get<std::string>();
 }
 std::string HueLight::getUId() const
 {
-    return state.GetValue().value("uniqueid", std::string());
+    return state.getValue().value("uniqueid", std::string());
 }
 std::string HueLight::getManufacturername() const
 {
-    return state.GetValue().value("manufacturername", std::string());
+    return state.getValue().value("manufacturername", std::string());
 }
 std::string HueLight::getProductname() const
 {
-    return state.GetValue().value("productname", std::string());
+    return state.getValue().value("productname", std::string());
 }
 std::string HueLight::getLuminaireUId() const
 {
-    return state.GetValue().value("luminaireuniqueid", std::string());
+    return state.getValue().value("luminaireuniqueid", std::string());
 }
 std::string HueLight::getSwVersion()
 {
-    return state.GetValue()["swversion"].get<std::string>();
+    return state.getValue()["swversion"].get<std::string>();
 }
 std::string HueLight::getSwVersion() const
 {
-    return state.GetValue()["swversion"].get<std::string>();
+    return state.getValue()["swversion"].get<std::string>();
 }
 bool HueLight::setName(const std::string& name)
 {
     nlohmann::json request = nlohmann::json::object();
     request["name"] = name;
-    nlohmann::json reply = SendPutRequest(request, "/name", CURRENT_FILE_INFO);
-    state.Refresh();
+    nlohmann::json reply = sendPutRequest(request, "/name", CURRENT_FILE_INFO);
+    state.refresh();
     // Check whether request was successful (returned name is not necessarily the actually set name)
     // If it already exists, a number is added, if it is too long to be returned, "Updated" is returned
@@ -141,7 +141,12 @@ bool HueLight::alert()
 StateTransaction HueLight::transaction()
 {
-    return StateTransaction(commands, "/lights/" + std::to_string(id) + "/state", state.GetValue().at("state"));
+    return StateTransaction(commands, "/lights/" + std::to_string(id) + "/state", state.getValue().at("state"));
+}
+
+void HueLight::refresh()
+{
+    state.refresh();
 }
 HueLight::HueLight(int id, const HueCommandAPI& commands) : HueLight(id, commands, nullptr, nullptr, nullptr) {}
@@ -157,10 +162,10 @@ HueLight::HueLight(int id, const HueCommandAPI&amp; commands, std::shared_ptr&lt;const 
       colorHueStrategy(std::move(colorHueStrategy)),
       commands(commands)
 {
-    state.Refresh();
+    state.refresh();
 }
-nlohmann::json HueLight::SendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo)
+nlohmann::json HueLight::sendPutRequest(const nlohmann::json& request, const std::string& subPath, FileInfo fileInfo)
 {
     return commands.PUTRequest("/lights/" + std::to_string(id) + subPath, request, std::move(fileInfo));
 }
@@ -39,11 +39,11 @@ bool SimpleBrightnessStrategy::setBrightness(unsigned int bri, uint8_t transitio
 unsigned int SimpleBrightnessStrategy::getBrightness(HueLight& light) const
 {
-    return light.state.GetValue()["state"]["bri"].get<unsigned int>();
+    return light.state.getValue()["state"]["bri"].get<unsigned int>();
 }
 unsigned int SimpleBrightnessStrategy::getBrightness(const HueLight& light) const
 {
-    return light.state.GetValue()["state"]["bri"].get<unsigned int>();
+    return light.state.getValue()["state"]["bri"].get<unsigned int>();
 }
 } // namespace hueplusplus
@@ -86,7 +86,7 @@ bool SimpleColorHueStrategy::setColorLoop(bool on, HueLight&amp; light) const
 bool SimpleColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -146,7 +146,7 @@ bool SimpleColorHueStrategy::alertHueSaturation(uint16_t hue, uint8_t sat, HueLi
 bool SimpleColorHueStrategy::alertXY(float x, float y, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -206,7 +206,7 @@ bool SimpleColorHueStrategy::alertXY(float x, float y, HueLight&amp; light) const
 bool SimpleColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "hs")
@@ -266,25 +266,26 @@ bool SimpleColorHueStrategy::alertRGB(uint8_t r, uint8_t g, uint8_t b, HueLight&amp;
 std::pair<uint16_t, uint8_t> SimpleColorHueStrategy::getColorHueSaturation(HueLight& light) const
 {
     // Save value, so there are no inconsistent results if it is refreshed between two calls
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     return std::make_pair(state["hue"].get<uint16_t>(), state["sat"].get<uint8_t>());
 }
 std::pair<uint16_t, uint8_t> SimpleColorHueStrategy::getColorHueSaturation(const HueLight& light) const
 {
-    return std::make_pair(light.state.GetValue()["state"]["hue"].get<uint16_t>(), light.state.GetValue()["state"]["sat"].get<uint8_t>());
+    return std::make_pair(light.state.getValue()["state"]["hue"].get<uint16_t>(), 
+        light.state.getValue()["state"]["sat"].get<uint8_t>());
 }
 std::pair<float, float> SimpleColorHueStrategy::getColorXY(HueLight& light) const
 {
     // Save value, so there are no inconsistent results if it is refreshed between two calls
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     return std::make_pair(state["xy"][0].get<float>(), state["xy"][1].get<float>());
 }
 std::pair<float, float> SimpleColorHueStrategy::getColorXY(const HueLight& light) const
 {
-    return std::make_pair(light.state.GetValue()["state"]["xy"][0].get<float>(), light.state.GetValue()["state"]["xy"][1].get<float>());
+    return std::make_pair(light.state.getValue()["state"]["xy"][0].get<float>(), light.state.getValue()["state"]["xy"][1].get<float>());
 }
 /*bool SimpleColorHueStrategy::pointInTriangle(float pointx, float pointy, float
 x0, float y0, float x1, float y1, float x2, float y2)
@@ -40,7 +40,7 @@ bool SimpleColorTemperatureStrategy::setColorTemperature(unsigned int mired, uin
 bool SimpleColorTemperatureStrategy::alertTemperature(unsigned int mired, HueLight& light) const
 {
     // Careful, only use state until any light function might refresh the value and invalidate the reference
-    const nlohmann::json& state = light.state.GetValue()["state"];
+    const nlohmann::json& state = light.state.getValue()["state"];
     std::string cType = state["colormode"].get<std::string>();
     bool on = state["on"].get<bool>();
     if (cType == "ct")
@@ -74,11 +74,11 @@ bool SimpleColorTemperatureStrategy::alertTemperature(unsigned int mired, HueLig
 unsigned int SimpleColorTemperatureStrategy::getColorTemperature(HueLight& light) const
 {
-    return light.state.GetValue()["state"]["ct"].get<unsigned int>();
+    return light.state.getValue()["state"]["ct"].get<unsigned int>();
 }
 unsigned int SimpleColorTemperatureStrategy::getColorTemperature(const HueLight& light) const
 {
-    return light.state.GetValue()["state"]["ct"].get<unsigned int>();
+    return light.state.getValue()["state"]["ct"].get<unsigned int>();
 }
 } // namespace hueplusplus
@@ -42,18 +42,18 @@ bool StateTransaction::commit() &amp;&amp;
     {
         if (!request.count("on"))
         {
-            if (request.value("bri", 254) == 0 && state.value("on", true))
-            {
-                // Turn off if brightness is 0
-                request["on"] = false;
-            }
-            else if (!state.value("on", false)
+            if (!state.value("on", false)
                 && (request.value("bri", 0) != 0 || request.count("effect") || request.count("hue")
                     || request.count("sat") || request.count("xy") || request.count("ct")))
             {
                 // Turn on if it was turned off
                 request["on"] = true;
             }
+            else if(request.value("bri", 254) == 0 && state.value("on", true))
+            {
+                // Turn off if brightness is 0
+                request["on"] = false;
+            }
         }
         nlohmann::json reply = commands.PUTRequest(path, request, CURRENT_FILE_INFO);
@@ -43,7 +43,7 @@ public:
         // Set refresh duration to max, so random refreshes do not hinder the test setups
     }
-    nlohmann::json& getState() { return state.GetValue(); }
+    nlohmann::json& getState() { return state.getValue(); }
     MOCK_METHOD1(On, bool(uint8_t transition));
@@ -125,7 +125,7 @@ public:
     MOCK_METHOD1(setColorLoop, bool(bool on));
-    MOCK_METHOD3(SendPutRequest,
+    MOCK_METHOD3(sendPutRequest,
         nlohmann::json(const nlohmann::json& request, const std::string& subPath, hueplusplus::FileInfo fileInfo));
 };
@@ -29,28 +29,28 @@
 using namespace hueplusplus;
-TEST(APICache, GetRefreshDuration)
+TEST(APICache, getRefreshDuration)
 {
     auto handler = std::make_shared<MockHttpHandler>();
     HueCommandAPI commands(getBridgeIp(), getBridgePort(), getBridgeUsername(), handler);
     {
         std::chrono::steady_clock::duration refresh = std::chrono::seconds(20);
         APICache cache("", commands, refresh);
-        EXPECT_EQ(refresh, cache.GetRefreshDuration());
+        EXPECT_EQ(refresh, cache.getRefreshDuration());
     }
     {
         std::chrono::steady_clock::duration refresh = std::chrono::seconds(0);
         APICache cache("", commands, refresh);
-        EXPECT_EQ(refresh, cache.GetRefreshDuration());
+        EXPECT_EQ(refresh, cache.getRefreshDuration());
     }
     {
         std::chrono::steady_clock::duration refresh = std::chrono::steady_clock::duration::max();
         APICache cache("", commands, refresh);
-        EXPECT_EQ(refresh, cache.GetRefreshDuration());
+        EXPECT_EQ(refresh, cache.getRefreshDuration());
     }
 }
-TEST(APICache, Refresh)
+TEST(APICache, refresh)
 {
     using namespace ::testing;
     auto handler = std::make_shared<MockHttpHandler>();
@@ -62,7 +62,7 @@ TEST(APICache, Refresh)
         EXPECT_CALL(*handler,
             GETJson("/api/" + getBridgeUsername() + path, nlohmann::json::object(), getBridgeIp(), getBridgePort()))
             .WillOnce(Return(nlohmann::json::object()));
-        cache.Refresh();
+        cache.refresh();
         Mock::VerifyAndClearExpectations(handler.get());
     }
     {
@@ -73,13 +73,13 @@ TEST(APICache, Refresh)
                 "/api/" + getBridgeUsername() + path, nlohmann::json::object(), getBridgeIp(), getBridgePort()))
             .Times(2)
             .WillRepeatedly(Return(nlohmann::json::object()));
-        cache.Refresh();
-        cache.Refresh();
+        cache.refresh();
+        cache.refresh();
         Mock::VerifyAndClearExpectations(handler.get());
     }
 }
-TEST(APICache, GetValue)
+TEST(APICache, getValue)
 {
     using namespace ::testing;
     auto handler = std::make_shared<MockHttpHandler>();
@@ -94,8 +94,8 @@ TEST(APICache, GetValue)
             GETJson("/api/" + getBridgeUsername() + path, nlohmann::json::object(), getBridgeIp(), getBridgePort()))
             .Times(2)
             .WillRepeatedly(Return(value));
-        EXPECT_EQ(value, cache.GetValue());
-        EXPECT_EQ(value, cache.GetValue());
+        EXPECT_EQ(value, cache.getValue());
+        EXPECT_EQ(value, cache.getValue());
         Mock::VerifyAndClearExpectations(handler.get());
     }
     // Only refresh once
@@ -106,8 +106,8 @@ TEST(APICache, GetValue)
         EXPECT_CALL(*handler,
             GETJson("/api/" + getBridgeUsername() + path, nlohmann::json::object(), getBridgeIp(), getBridgePort()))
             .WillOnce(Return(value));
-        EXPECT_EQ(value, cache.GetValue());
-        EXPECT_EQ(value, cache.GetValue());
+        EXPECT_EQ(value, cache.getValue());
+        EXPECT_EQ(value, cache.getValue());
         Mock::VerifyAndClearExpectations(handler.get());
     }
     // No refresh with const
@@ -118,7 +118,7 @@ TEST(APICache, GetValue)
         EXPECT_CALL(*handler,
             GETJson("/api/" + getBridgeUsername() + path, nlohmann::json::object(), getBridgeIp(), getBridgePort()))
             .Times(0);
-        EXPECT_EQ(nullptr, cache.GetValue());
+        EXPECT_EQ(nullptr, cache.getValue());
         Mock::VerifyAndClearExpectations(handler.get());
     }
 }
 \ No newline at end of file
@@ -56,7 +56,7 @@ TEST(ExtendedColorTemperatureStrategy, setColorTemperature)
     prep_ret[2] = nlohmann::json::object();
     prep_ret[2]["success"] = nlohmann::json::object();
     prep_ret[2]["success"]["/lights/1/state/ct"] = 155;
-    EXPECT_CALL(test_light, SendPutRequest(_, "/state", _)).Times(1).WillOnce(Return(prep_ret));
+    EXPECT_CALL(test_light, sendPutRequest(_, "/state", _)).Times(1).WillOnce(Return(prep_ret));
     test_light.getState()["state"]["colormode"] = "ct";
     test_light.getState()["state"]["on"] = true;
@@ -67,11 +67,11 @@ TEST(ExtendedColorTemperatureStrategy, setColorTemperature)
     EXPECT_EQ(true, ExtendedColorTemperatureStrategy().setColorTemperature(155, 6, test_light));
     prep_ret[2]["success"]["/lights/1/state/ct"] = 153;
-    EXPECT_CALL(test_light, SendPutRequest(_, "/state", _)).Times(1).WillOnce(Return(prep_ret));
+    EXPECT_CALL(test_light, sendPutRequest(_, "/state", _)).Times(1).WillOnce(Return(prep_ret));
     EXPECT_EQ(true, ExtendedColorTemperatureStrategy().setColorTemperature(0, 6, test_light));
     prep_ret[2]["success"]["/lights/1/state/ct"] = 500;
-    EXPECT_CALL(test_light, SendPutRequest(_, "/state", _)).Times(1).WillOnce(Return(prep_ret));
+    EXPECT_CALL(test_light, sendPutRequest(_, "/state", _)).Times(1).WillOnce(Return(prep_ret));
     EXPECT_EQ(true, ExtendedColorTemperatureStrategy().setColorTemperature(600, 6, test_light));
 }