colour_control.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================

#ifndef HF_ITF_COLOUR_CONTROL_H
#define HF_ITF_COLOUR_CONTROL_H

#include "hanfun/protocol.h"
#include "hanfun/interface.h"

namespace HF
{
   namespace Interfaces
   {
      // Forward declaration.
      namespace ColourControl
      {
         class IServer;
      }

      HF::Attributes::IAttribute *create_attribute(ColourControl::IServer *server, uint8_t uid);

      namespace ColourControl
      {
         typedef enum _CMD
         {
            MOVE_TO_HUE_CMD                = 0x01, 
            MOVE_HUE_CMD                   = 0x02, 
            STEP_HUE_CMD                   = 0x03, 
            MOVE_TO_SATURATION_CMD         = 0x04, 
            MOVE_SATURATION_CMD            = 0x05, 
            STEP_SATURATION_CMD            = 0x06, 
            MOVE_TO_HUE_AND_SATURATION_CMD = 0x07, 
            MOVE_TO_XY_CMD                 = 0x08, 
            MOVE_XY_CMD                    = 0x09, 
            STEP_XY_CMD                    = 0x0a, 
            MOVE_TO_COLOUR_TEMPERATURE_CMD = 0x0b, 
            STOP_CMD                       = 0x0c, 
            __LAST_CMD__                   = STOP_CMD
         } CMD;

         typedef enum _Attributes
         {
            SUPPORTED_ATTR          = 0x01,  
            MODE_ATTR               = 0x02,  
            HUE_AND_SATURATION_ATTR = 0x03,  
            XY_ATTR                 = 0x04,  
            COLOUR_TEMPERATURE_ATTR = 0x05,  
            __LAST_ATTR__           = COLOUR_TEMPERATURE_ATTR
         } Attributes;

         typedef enum _Mask : uint8_t
         {
            HS_MODE          = 0x01,               
            XY_MODE          = 0x02,               
            TEMPERATURE_MODE = 0x04,               
            __LAST_MODE__    = TEMPERATURE_MODE
         } Mask;

         typedef enum _Direction : uint8_t
         {
            UP                = 0x01,
            DOWN              = 0x02,
            SHORTEST          = 0x03,
            LONGEST           = 0x04,
            __LAST_DIRECTION_ = LONGEST
         } Direction;

         struct HS_Colour
         {
            uint16_t hue;
            uint8_t  saturation;

            HS_Colour() = default;

            HS_Colour(uint16_t _hue, uint8_t _saturation):
               saturation(_saturation)
            {
               hue = _hue < HUE ? _hue : HUE - 1;
            }

            static constexpr int HUE        = 360;
            static constexpr int SATURATION = 0x100;

            static int32_t invert_angle(int32_t angle, uint16_t max_value);

            static int32_t get_travel_distance(const Direction dir, uint16_t initial,
                                               uint16_t final, uint16_t max);

            static constexpr uint16_t min_size = sizeof(hue)            // hue
                                                 + sizeof(saturation);  // saturation

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);

            int compare(const HS_Colour &other) const
            {
               if (this->hue != other.hue)
               {
                  return (this->hue - other.hue);
               }
               else
               {
                  if (this->hue != other.hue)
                  {
                     return (this->hue - other.hue);
                  }
                  else
                  {
                     return 0;
                  }
               }
            }

            float changed(const HS_Colour &other) const
            {
               if (this->hue != other.hue)
               {
                  return (100 * (this->hue - other.hue) / static_cast<float>(this->hue));
               }
               else
               {
                  if (this->hue != other.hue)
                  {
                     return (100 * (this->hue - other.hue) / static_cast<float>(this->hue));
                  }
                  else
                  {
                     return 0.0f;
                  }
               }
            }

            bool operator==(const HS_Colour &other) const
            {
               return (hue == other.hue && saturation == other.saturation);
            }

            bool operator!=(const HS_Colour &other) const
            {
               return !operator==(other);
            }
         };

         struct XY_Colour
         {
            uint16_t X;
            uint16_t Y;

            XY_Colour() = default;

            XY_Colour(uint16_t X, uint16_t Y): X(X), Y(Y)
            {}

            static constexpr uint16_t min_size = sizeof(X)    // X
                                                 + sizeof(Y); // Y

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);

            int compare(const XY_Colour &other) const
            {
               if (this->X != other.X)
               {
                  return (this->X - other.X);
               }
               else
               {
                  if (this->Y != other.Y)
                  {
                     return (this->Y - other.Y);
                  }
                  else
                  {
                     return 0;
                  }
               }
            }

            float changed(const XY_Colour &other) const
            {
               if (this->X != other.X)
               {
                  return (100 * (this->X - other.X) / static_cast<float>(this->X));
               }
               else
               {
                  if (this->Y != other.Y)
                  {
                     return (100 * (this->Y - other.Y) / static_cast<float>(this->Y));
                  }
                  else
                  {
                     return 0.0f;
                  }
               }
            }

            bool operator==(const XY_Colour &other) const
            {
               return (X == other.X && Y == other.Y);
            }

            bool operator!=(const XY_Colour &other) const
            {
               return !operator==(other);
            }
         };

         // =============================================================================
         // Attribute Helper classes
         // =============================================================================

         struct Supported: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = SUPPORTED_ATTR; 
            static constexpr bool    WRITABLE = false;          

            static constexpr uint8_t get_suport(void)
            {
               return
#ifdef HF_ITF_COLOUR_CONTROL_HUE_AND_SATURATION_ATTR
                  Mask::HS_MODE +
#endif
#ifdef HF_ITF_COLOUR_CONTROL_XY_ATTR
                  Mask::XY_MODE +
#endif
#ifdef HF_ITF_COLOUR_CONTROL_HUE_AND_SATURATION_ATTR
                  Mask::TEMPERATURE_MODE
#endif
               ;
            }

            Supported(uint8_t value = get_suport(), HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::COLOUR_CONTROL, ID, owner, value, WRITABLE)
            {}
         };

         struct Mode: public HF::Attributes::Attribute<uint8_t>
         {
            static constexpr uint8_t ID       = MODE_ATTR; 
            static constexpr bool    WRITABLE = false;     

            Mode(uint8_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint8_t>(HF::Interface::COLOUR_CONTROL, ID, owner, value, WRITABLE)
            {}
         };

         struct HueAndSaturation: public HF::Attributes::Attribute<HS_Colour>
         {
            static constexpr uint8_t ID       = HUE_AND_SATURATION_ATTR; 
            static constexpr bool    WRITABLE = false;                   

            HueAndSaturation(HS_Colour value = HS_Colour(0, 0), HF::Interface *owner = nullptr):
               Attribute<HS_Colour>(HF::Interface::COLOUR_CONTROL, ID, owner, value, WRITABLE)
            {}
         };

         struct Xy: public HF::Attributes::Attribute<XY_Colour>
         {
            static constexpr uint8_t ID       = XY_ATTR; 
            static constexpr bool    WRITABLE = false;   

            Xy(XY_Colour value = XY_Colour(0, 0), HF::Interface *owner = nullptr):
               Attribute<XY_Colour>(HF::Interface::COLOUR_CONTROL, ID, owner, value, WRITABLE)
            {}
         };

         struct ColourTemperature: public HF::Attributes::Attribute<uint16_t>
         {
            static constexpr uint8_t ID       = COLOUR_TEMPERATURE_ATTR; 
            static constexpr bool    WRITABLE = false;                   

            ColourTemperature(uint16_t value = 0, HF::Interface *owner = nullptr):
               Attribute<uint16_t>(HF::Interface::COLOUR_CONTROL, ID, owner, value, WRITABLE)
            {}
         };

         HF::Attributes::IAttribute *create_attribute(uint8_t uid);

         // =============================================================================
         // Commands Messages classes
         // =============================================================================

         struct MoveToHueMessage
         {
            uint16_t  hue;                       
            Direction direction;                 
            uint16_t  time;                      

            MoveToHueMessage(uint16_t hue = 0, Direction direction = Direction::SHORTEST,
                             uint16_t time = 0): direction(direction), time(time)
            {
               this->hue = hue < HS_Colour::HUE ? hue : HS_Colour::HUE - 1;
            }

            static constexpr uint16_t min_size = sizeof(hue)            // Hue
                                                 + sizeof(uint8_t)      // Direction
                                                 + sizeof(time);        // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveHueMessage
         {
            Direction direction;   
            uint16_t  rate;        

            MoveHueMessage(Direction dir = Direction::UP, uint16_t rate = 0):
               direction(dir), rate(rate)
            {
               this->rate = (rate < HS_Colour::HUE ? rate : HS_Colour::HUE - 1);
            }

            static constexpr uint16_t min_size = sizeof(uint8_t)     // Direction
                                                 + sizeof(rate);     // Rate

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct StepHueMessage
         {
            uint8_t   step_size;                
            Direction direction;                
            uint8_t   time;                     
            StepHueMessage(uint8_t step_size = 0, Direction dir = Direction::UP, uint8_t time = 0):
               step_size(step_size), direction(dir), time(time)
            {}

            static constexpr uint16_t min_size = sizeof(step_size) // Step size
                                                 + sizeof(uint8_t) // Direction
                                                 + sizeof(time);   // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveToSaturationMessage
         {
            uint8_t   saturation;                
            Direction direction;                 
            uint16_t  time;                      

            MoveToSaturationMessage(uint8_t saturation = 0,
                                    Direction dir = Direction::UP,
                                    uint16_t time = 0):
               saturation(saturation), direction(dir), time(time)
            {}

            static constexpr uint16_t min_size = sizeof(saturation)     // Step size
                                                 + sizeof(uint8_t)      // Direction
                                                 + sizeof(time);        // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveSaturationMessage
         {
            Direction direction;                
            uint8_t   rate;                     

            MoveSaturationMessage(Direction dir = Direction::UP, uint8_t rate = 0):
               direction(dir), rate(rate)
            {}

            static constexpr uint16_t min_size = sizeof(uint8_t)     // Direction
                                                 + sizeof(rate);     // Rate

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct StepSaturationMessage
         {
            uint8_t   step_size;                
            Direction direction;                
            uint8_t   time;                     

            StepSaturationMessage(uint8_t step_size = 0,
                                  Direction dir = Direction::UP,
                                  uint8_t time = 0):
               step_size(step_size), direction(dir), time(time)
            {}

            static constexpr uint16_t min_size = sizeof(step_size) // Step size
                                                 + sizeof(uint8_t) // Direction
                                                 + sizeof(time);   // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveToHueSaturationMessage
         {
            HS_Colour colour;                    
            Direction direction;                 
            uint16_t  time;                      

            MoveToHueSaturationMessage(HS_Colour colour = HS_Colour(0, 0),
                                       Direction dir = Direction::UP,
                                       uint16_t time = 0):
               colour(colour), direction(dir), time(time)
            {}

            static constexpr uint16_t min_size = HS_Colour::min_size    // HS colour
                                                 + sizeof(uint8_t)      // Direction
                                                 + sizeof(time);        // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveToXYMessage
         {
            XY_Colour colour;
            uint16_t  time;         

            MoveToXYMessage(XY_Colour colour = XY_Colour(0, 0), uint16_t time = 0):
               colour(colour), time(time)
            {}

            static constexpr uint16_t min_size = sizeof(XY_Colour::X)   // X
                                                 + sizeof(XY_Colour::Y) // Y
                                                 + sizeof(time);        // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveXYMessage
         {
            int16_t X_rate;   
            int16_t Y_rate;   

            MoveXYMessage(int16_t X_rate = 0, int16_t Y_rate = 0):
               X_rate(X_rate), Y_rate(Y_rate)
            {}

            static constexpr uint16_t min_size = sizeof(X_rate)    // X_rate
                                                 + sizeof(Y_rate); // Y_rate

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct StepXYMessage
         {
            int16_t X_step;   
            int16_t Y_step;   
            uint8_t time;     

            StepXYMessage(int16_t X_step = 0, int16_t Y_step = 0, uint8_t time = 0):
               X_step(X_step), Y_step(Y_step), time(time)
            {}

            static constexpr uint16_t min_size = sizeof(X_step)   // X_step
                                                 + sizeof(Y_step) // Y_step
                                                 + sizeof(time);  // Time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct MoveToTemperatureMessage
         {
            uint16_t colour;
            uint16_t time;    

            MoveToTemperatureMessage(uint16_t colour = 0, uint16_t time = 0):
               colour(colour), time(time)
            {}

            static constexpr uint16_t min_size = sizeof(colour)  // temperature
                                                 + sizeof(time); // time

            uint16_t size() const
            {
               return min_size;
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const;

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0);
         };

         struct Base: public Interface<HF::Interface::COLOUR_CONTROL>
         {
            protected:

            Base(): Interface<HF::Interface::COLOUR_CONTROL>() {}
         };

         struct ITransition
         {
            IServer  &server;          

            uint16_t period;           
            uint16_t remaining_time;   

            ITransition(IServer &_server, uint16_t period):
               server(_server), period(period), remaining_time(period)
            {}

            virtual ~ITransition()
            {}

            virtual bool run(uint16_t time)
            {
               remaining_time -= time;

               if (remaining_time == 0)
               {
                  remaining_time = this->period;
                  return true;
               }

               return false;
            }

            virtual bool next() = 0;
         };


         struct Hue_Transition: public ITransition
         {
            int32_t  step;    
            uint16_t n_steps; 
            uint16_t end;     

            Hue_Transition(IServer &_server, uint16_t period, int32_t step = 0,
                           uint16_t n_steps = 0, uint16_t end = 0):
               ITransition(_server, period), step(step), n_steps(n_steps), end(end)
            {}

            Hue_Transition() = default;

            ~Hue_Transition()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct Hue_Transition_Continuous: public ITransition
         {
            int32_t step;     

            Hue_Transition_Continuous(IServer &_server, uint16_t period, int32_t step = 0):
               ITransition(_server, period), step(step)
            {}

            Hue_Transition_Continuous() = default;

            ~Hue_Transition_Continuous()
            {}

            // @copydoc ColourControl::Hue_Transition::run()
            bool run(uint16_t time);

            // @copydoc ITransition::next()
            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct Saturation_Transition: public ITransition
         {
            int32_t  step;    
            uint16_t n_steps; 
            uint16_t end;     

            Saturation_Transition(IServer &_server, uint16_t period, int32_t step = 0,
                                  uint16_t n_steps = 0,
                                  uint16_t end = 0):
               ITransition(_server, period), step(step), n_steps(n_steps), end(end)
            {}

            Saturation_Transition() = default;

            ~Saturation_Transition()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct Saturation_Transition_Continuous: public ITransition
         {
            int32_t step;     

            Saturation_Transition_Continuous(IServer &_server, uint16_t period, int32_t step = 0):
               ITransition(_server, period), step(step)
            {}

            Saturation_Transition_Continuous() = default;

            ~Saturation_Transition_Continuous()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct HS_Transition: public ITransition
         {
            int32_t   hue_step; 
            int32_t   sat_step; 
            uint16_t  n_steps;  
            HS_Colour end;      

            HS_Transition(IServer &_server, uint16_t period,
                          int32_t hue_step = 0, int32_t sat_step = 0,
                          uint16_t n_steps = 0, HS_Colour end = HS_Colour(0, 0)):
               ITransition(_server, period), hue_step(hue_step),
               sat_step(sat_step), n_steps(n_steps), end(end)
            {}

            HS_Transition() = default;

            ~HS_Transition()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct XY_Transition: public ITransition
         {
            int32_t   X_step;  
            int32_t   Y_step;  
            uint16_t  n_steps; 
            XY_Colour end;     

            XY_Transition(IServer &_server, uint16_t period,
                          int32_t X_step = 0, int32_t Y_step = 0,
                          uint16_t n_steps = 0,
                          XY_Colour end = XY_Colour(0, 0)):
               ITransition(_server, period), X_step(X_step), Y_step(Y_step),
               n_steps(n_steps), end(end)
            {}

            XY_Transition() = default;

            ~XY_Transition()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct XY_Transition_Continuous: public ITransition
         {
            int16_t X_step;   
            int16_t Y_step;   

            XY_Transition_Continuous(IServer &_server, uint16_t period,
                                     int16_t X_step = 0, int16_t Y_step = 0):
               ITransition(_server, period), X_step(X_step), Y_step(Y_step)
            {}

            XY_Transition_Continuous() = default;

            ~XY_Transition_Continuous()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         struct Temperature_Transition: public ITransition
         {
            int32_t  step;    
            uint16_t n_steps; 
            uint16_t end;     

            Temperature_Transition(IServer &_server, uint16_t period,
                                   int32_t step = 0,
                                   uint16_t n_steps = 0,
                                   uint16_t end = 0):
               ITransition(_server, period), step(step),
               n_steps(n_steps), end(end)
            {}

            Temperature_Transition() = default;

            ~Temperature_Transition()
            {}

            bool run(uint16_t time);

            bool next()
            {
               return (period != 0 ? true : false);
            }
         };

         class IServer: public InterfaceRole<ColourControl::Base, HF::Interface::SERVER_ROLE>
         {
            protected:

            uint8_t _supported; 
            uint8_t _mode;      

#ifdef HF_ITF_COLOUR_CONTROL_HUE_AND_SATURATION_ATTR

            HS_Colour _hue_and_saturation;   

#endif

#ifdef HF_ITF_COLOUR_CONTROL_XY_ATTR

            XY_Colour _xy;   

#endif

#ifdef HF_ITF_COLOUR_CONTROL_COLOUR_TEMPERATURE_ATTR

            uint16_t _colour_temperature;   

#endif

            public:

            IServer(): InterfaceRole<ColourControl::Base, HF::Interface::SERVER_ROLE>() {}

            virtual ~IServer() {}

            // ======================================================================
            // Events
            // ======================================================================

            virtual Common::Result move_to_hue(const Protocol::Address &addr,
                                               const MoveToHueMessage &message);

            virtual Common::Result move_hue(const Protocol::Address &addr,
                                            const MoveHueMessage &message);

            virtual Common::Result step_hue(const Protocol::Address &addr,
                                            const StepHueMessage &message);

            virtual Common::Result move_to_saturation(const Protocol::Address &addr,
                                                      const MoveToSaturationMessage &message);

            virtual Common::Result move_saturation(const Protocol::Address &addr,
                                                   const MoveSaturationMessage &message);

            virtual Common::Result step_saturation(const Protocol::Address &addr,
                                                   const StepSaturationMessage &message);

            virtual Common::Result move_to_hue_and_saturation(const Protocol::Address &addr,
                                                              const MoveToHueSaturationMessage &message);

            virtual Common::Result move_to_xy(const Protocol::Address &addr,
                                              const MoveToXYMessage &message);

            virtual Common::Result move_xy(const Protocol::Address &addr,
                                           const MoveXYMessage &message);

            virtual Common::Result step_xy(const Protocol::Address &addr,
                                           const StepXYMessage &message);

            virtual Common::Result move_to_colour_temperature(const Protocol::Address &addr,
                                                              const MoveToTemperatureMessage &message);

#ifdef HF_ITF_COLOUR_CONTROL_STOP_CMD

            virtual Common::Result stop(const Protocol::Address &addr);

#endif

            // ======================================================================

            // =============================================================================
            // Get/Set API.
            // =============================================================================

            uint8_t supported() const;

            void supported(uint8_t __value);

            uint8_t mode() const;

            void mode(uint8_t __value);

#ifdef HF_ITF_COLOUR_CONTROL_HUE_AND_SATURATION_ATTR

            HS_Colour hue_and_saturation() const;

            void hue_and_saturation(HS_Colour __value);

#endif

#ifdef HF_ITF_COLOUR_CONTROL_XY_ATTR

            XY_Colour xy() const;

            void xy(XY_Colour __value);

#endif

#ifdef HF_ITF_COLOUR_CONTROL_COLOUR_TEMPERATURE_ATTR

            uint16_t colour_temperature() const;

            void colour_temperature(uint16_t __value);

#endif

            // =============================================================================
            // Attribute API.
            // =============================================================================

            HF::Attributes::IAttribute *attribute(uint8_t uid);

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const;

            protected:

            Common::Result handle_command(Protocol::Packet &packet, Common::ByteArray &payload,
                                          uint16_t offset);
         };

         struct Server: public IServer
         {
            typedef typename std::vector<ITransition *> Container;

            public:

            Server(): IServer()
            {}

            virtual ~Server()
            {}

            static uint16_t has_transitions()
            {
               return transitions.empty() ? 0 : transitions.front()->remaining_time;
            }

            static uint16_t transition(void);

            // ======================================================================
            // Events
            // ======================================================================

            virtual void changed(void) {}

            Common::Result move_to_hue(const Protocol::Address &addr,
                                       const MoveToHueMessage &message);

            Common::Result move_hue(const Protocol::Address &addr,
                                    const MoveHueMessage &message);

            Common::Result step_hue(const Protocol::Address &addr,
                                    const StepHueMessage &message);

            Common::Result move_to_saturation(const Protocol::Address &addr,
                                              const MoveToSaturationMessage &message);

            Common::Result move_saturation(const Protocol::Address &addr,
                                           const MoveSaturationMessage &message);

            Common::Result step_saturation(const Protocol::Address &addr,
                                           const StepSaturationMessage &message);

            Common::Result move_to_hue_and_saturation(const Protocol::Address &addr,
                                                      const MoveToHueSaturationMessage &message);

            Common::Result move_to_xy(const Protocol::Address &addr,
                                      const MoveToXYMessage &message);

            Common::Result move_xy(const Protocol::Address &addr,
                                   const MoveXYMessage &message);

            Common::Result step_xy(const Protocol::Address &addr,
                                   const StepXYMessage &message);

            Common::Result move_to_colour_temperature(const Protocol::Address &addr,
                                                      const MoveToTemperatureMessage &message);

#ifdef HF_ITF_COLOUR_CONTROL_STOP_CMD
            Common::Result stop(const Protocol::Address &addr);
#endif

            protected:

            static Container transitions;

            void add_transition(ITransition *t)
            {
               transitions.push_back(t);
               changed();
            }

            void remove(IServer const &itf)
            {
               auto compare = [&itf](ITransition *entry)
                              {
                                 if (&(entry->server) == &(itf))
                                 {
                                    delete entry;
                                    return true;
                                 }

                                 return false;
                              };

               transitions.erase(std::remove_if(transitions.begin(), transitions.end(),
                                                compare), transitions.end());
            }
         };

         struct Client: public InterfaceRole<ColourControl::Base, HF::Interface::CLIENT_ROLE>
         {
            Client(): InterfaceRole<ColourControl::Base, HF::Interface::CLIENT_ROLE>() {}

            virtual ~Client() {}

            // ======================================================================
            // Commands
            // ======================================================================

            void move_to_hue(const Protocol::Address &addr, uint16_t hue,
                             Direction direction, uint16_t transition);

            void move_hue(const Protocol::Address &addr, Direction direction, uint16_t rate);

            void step_hue(const Protocol::Address &addr, uint8_t step,
                          Direction direction, uint8_t time);

            void move_to_saturation(const Protocol::Address &addr, uint8_t saturation,
                                    Direction direction, uint16_t transition);

            void move_saturation(const Protocol::Address &addr, Direction direction, uint8_t rate);

            void step_saturation(const Protocol::Address &addr, uint8_t step,
                                 Direction direction, uint8_t time);

            void move_to_hue_and_saturation(const Protocol::Address &addr, HS_Colour colour,
                                            Direction direction, uint16_t time);

            void move_to_xy(const Protocol::Address &addr, XY_Colour colour, uint16_t time);

            void move_xy(const Protocol::Address &addr, int16_t X_rate, int16_t Y_rate);

            void step_xy(const Protocol::Address &addr, int16_t X_step,
                         int16_t Y_step, uint8_t time);

            void move_to_colour_temperature(const Protocol::Address &addr,
                                            uint16_t colour, uint16_t time);

            void stop(const Protocol::Address &addr);

            // ======================================================================
         };

      }  // namespace ColourControl

   }  // namespace Interfaces

}   // namespace HF

// =============================================================================
// Stream Helpers
// =============================================================================

std::ostream &operator<<(std::ostream &stream, const HF::Interfaces::ColourControl::CMD command);

std::ostream &operator<<(std::ostream &stream,
                         const HF::Interfaces::ColourControl::Attributes attribute);
#endif /* HF_ITF_COLOUR_CONTROL_H */