simple_air_pressure.h

Go to the documentation of this file.

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

#ifndef HF_ITF_SIMPLE_AIR_PRESSURE_H
#define HF_ITF_SIMPLE_AIR_PRESSURE_H

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

namespace HF
{
   namespace Interfaces
   {
      // Forward declaration.
      namespace SimpleAirPressure
      {
         class Server;
      }

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

      namespace SimpleAirPressure
      {
         typedef enum _Attributes
         {
            VALUE_ATTR     = 1, 
            MAXIMUM_ATTR   = 2, 
            MINIMUM_ATTR   = 3, 
            TOLERANCE_ATTR = 4, 
            __LAST_ATTR__  = TOLERANCE_ATTR
         } Attributes;

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

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

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

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

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

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

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

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

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

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

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

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

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

            uint16_t _value;     
            uint16_t _maximum;   
            uint16_t _minimum;   
            uint16_t _tolerance; 

            public:

            Server(): InterfaceRole<SimpleAirPressure::Base, HF::Interface::SERVER_ROLE>() {}

            virtual ~Server() {}

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

            uint16_t value() const;

            void value(uint16_t __value);

            uint16_t maximum() const;

            void maximum(uint16_t __value);

            uint16_t minimum() const;

            void minimum(uint16_t __value);

            uint16_t tolerance() const;

            void tolerance(uint16_t __value);

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

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

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

         };

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

            virtual ~Client() {}
         };

      }  // namespace SimpleAirPressure

   }  // namespace Interfaces

}   // namespace HF

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

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