alert.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_ITF_ALERT_H
#define HF_ITF_ALERT_H

#include "hanfun/common.h"

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

// =============================================================================
// API
// =============================================================================

namespace HF
{
   namespace Interfaces
   {
      // Forward declaration.
      namespace Alert
      {
         class Server;

      }  // namespace Alert

      HF::Attributes::IAttribute *create_attribute(HF::Interfaces::Alert::Server *server,
                                                   uint8_t uid);

      namespace Alert
      {
         typedef enum _CMD
         {
            STATUS_CMD   = 0x01,         
            __LAST_CMD__ = STATUS_CMD
         } CMD;

         typedef enum _Attributes
         {
            STATE_ATTR    = 0x01, 
            ENABLE_ATTR   = 0x02, 
            __LAST_ATTR__ = ENABLE_ATTR,
         } Attributes;

         struct Message
         {
            static constexpr uint16_t min_size = sizeof(uint16_t)    // Profile UID.
                                                 + sizeof(uint32_t); // State.

            uint16_t type;        
            uint32_t state;       

            Message(uint16_t type = 0, uint32_t state = 0);

            uint16_t size() const;

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

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

         struct State: public HF::Attributes::Attribute<uint32_t>
         {
            static constexpr uint8_t ID        = STATE_ATTR; 
            static constexpr bool    WRITABBLE = false;      

            State(uint32_t data = 0, const HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::ALERT, ID, owner, data, WRITABBLE)
            {}
         };

         struct Enable: public HF::Attributes::Attribute<uint32_t>
         {
            static constexpr uint8_t ID        = ENABLE_ATTR; 
            static constexpr bool    WRITABBLE = true;        

            Enable(uint32_t data = 0, const HF::Interface *owner = nullptr):
               Attribute<uint32_t>(HF::Interface::ALERT, ID, owner, data, WRITABBLE)
            {}
         };

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

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

            Base() {}

            using Interface<HF::Interface::ALERT>::payload_size;

            uint16_t payload_size(Protocol::Message::Interface &itf) const
            {
               UNUSED(itf);
               return payload_size_helper<Message>();
            }
         };

         class Server: public InterfaceRole<Alert::Base, HF::Interface::SERVER_ROLE>
         {
            protected:

            uint32_t _state;     
            uint32_t _enabled;   

            public:

            Server();

            virtual ~Server();

            // ======================================================================
            // State API
            // ======================================================================

            uint32_t state();

            void set_state(uint32_t value);

            bool state(uint8_t index, bool value);

            bool state(uint8_t index);

            void clear();

            // ======================================================================
            // Enable API
            // ======================================================================

            void enable(uint8_t index);

            void enableAll();

            bool enabled(uint8_t index);

            uint32_t enabled();

            void set_enabled(uint32_t value);

            void disable(uint8_t index);

            bool disabled(uint8_t index);

            void disableAll();

            // =============================================================================
            // Attributes API
            // =============================================================================

            HF::Attributes::IAttribute *attribute(uint8_t uid)
            {
               return Interfaces::create_attribute(this, uid);
            }

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

            void status(Protocol::Address &addr, uint16_t unit_type);

            void status(uint16_t unit_type)
            {
               Protocol::Address addr;
               status(addr, unit_type);
            }

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

            HF::Attributes::UIDS attributes(uint8_t pack_id =
                                               HF::Attributes::Pack::MANDATORY) const
            {
               UNUSED(pack_id);
               /* *INDENT-OFF* */
               return HF::Attributes::UIDS ({ Alert::STATE_ATTR, Alert::ENABLE_ATTR });
               /* *INDENT-ON* */
            }

            protected:

            Alert::Message *create_status(uint16_t unit_type);

         };

         struct Client: public InterfaceRole<Alert::Base, HF::Interface::CLIENT_ROLE>
         {
            // ======================================================================
            // Events
            // ======================================================================

            virtual void status(Protocol::Address &source, Message &message)
            {
               UNUSED(source);
               UNUSED(message);
            }

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

            protected:

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

      }  // namespace Alert

   }  // namespace Interfaces

}  // namespace HF

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

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

std::ostream &operator<<(std::ostream &stream, const HF::Interfaces::Alert::Attributes attribute);

#endif /* HF_ITF_ALERT_H */