attributes.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_ATTRIBUTES_H
#define HF_ATTRIBUTES_H

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

namespace HF
{
   struct Interface;

   namespace Attributes
   {
      struct IAttribute: public Common::Serializable, public Common::Cloneable<IAttribute>
      {
         virtual uint8_t uid() const = 0;

         virtual bool isWritable() const = 0;

         virtual uint16_t interface() const = 0;

         virtual HF::Interface const *owner() const = 0;

         using Common::Serializable::size;

         virtual uint16_t size(bool with_uid) const = 0;

         using Common::Serializable::pack;

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

         using Common::Serializable::unpack;

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

         virtual bool operator==(const IAttribute &other) const = 0;

         virtual bool operator<(const IAttribute &other) const  = 0;

         virtual bool operator>(const IAttribute &other) const  = 0;

         virtual float changed(const IAttribute &other) const = 0;

         virtual int compare(const IAttribute &other) const = 0;
      };

      typedef IAttribute * (*Factory)(uint8_t);

      typedef Attributes::Factory (*FactoryGetter)(Common::Interface);

      Factory get_factory(Common::Interface itf);

      struct UIDS: public std::vector<uint8_t>
      {
         UIDS(): std::vector<uint8_t>()
         {}

         UIDS(std::initializer_list<uint8_t> uids): vector<uint8_t>(uids)
         {}

         vector<uint8_t>::size_type length() const
         {
            return vector<uint8_t>::size();
         }

         static constexpr uint8_t min_size = sizeof(uint8_t);

         uint16_t size() const
         {
            return min_size + sizeof(uint8_t) * vector<uint8_t>::size();
         }

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

            uint16_t start = offset;

            uint8_t count  = length();
            offset += array.write(offset, count);

            /* *INDENT-OFF* */
            std::for_each (vector<uint8_t>::begin(), vector<uint8_t>::end(),
                           [&offset,&array](uint8_t uid)
            {
               offset += array.write (offset, uid);
            });
            /* *INDENT-ON* */

            return offset - start;
         }

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

            return unpack(array, offset, count);
         }

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset, uint8_t &count)
         {
            HF_SERIALIZABLE_CHECK(array, offset, min_size);

            uint16_t start = offset;

            offset += array.read(offset, count);

            HF_SERIALIZABLE_CHECK(array, offset, count);

            vector<uint8_t>::reserve(count);

            for (uint8_t i = 0; i < count; i++)
            {
               uint8_t uid;
               offset += array.read(offset, uid);
               vector<uint8_t>::push_back(uid);
            }

            return offset - start;
         }
      };

      class AbstractAttribute: public IAttribute
      {
         protected:

         const uint16_t _itf_uid;      
         const uint8_t _uid;           
         const bool _writable;         

         AbstractAttribute(const uint16_t itf_uid, const uint8_t uid, const bool writable = false):
            _itf_uid(itf_uid), _uid(uid), _writable(writable)
         {}

         public:

         uint8_t uid() const
         {
            return _uid;
         }

         bool isWritable() const
         {
            return _writable;
         }

         uint16_t interface() const
         {
            return _itf_uid;
         }

         bool operator==(const IAttribute &other) const
         {
            return this->compare(other) == 0;
         }

         bool operator==(IAttribute &other) const
         {
            return this->compare(other) == 0;
         }

         bool operator<(const IAttribute &other) const
         {
            return this->compare(other) < 0;
         }

         bool operator<(IAttribute &other) const
         {
            return this->compare(other) < 0;
         }

         bool operator>(const IAttribute &other) const
         {
            return this->compare(other) > 0;
         }

         bool operator>(IAttribute &other) const
         {
            return this->compare(other) > 0;
         }

         int compare(const IAttribute &other) const
         {
            int res = this->interface() - other.interface();

            if (res != 0)
            {
               return res;
            }

            return this->uid() - other.uid();
         }
      };

      template<typename T, typename _Owner = void, typename = void>
      struct Attribute: public AbstractAttribute
      {
         Attribute(const uint16_t interface, const uint8_t uid, const HF::Interface *__owner,
                   T data, bool writable = false):
            AbstractAttribute(interface, uid, writable), helper(data), _owner(__owner)
         {}

         Attribute(const uint16_t interface, const uint8_t uid, bool writable = false):
            AbstractAttribute(interface, uid, writable), _owner(nullptr)
         {}

         Attribute(const uint16_t interface, const uint8_t uid, T data, bool writable = false):
            AbstractAttribute(interface, uid, writable), helper(data), _owner(nullptr)
         {}

         typedef typename std::remove_reference<T>::type value_type;

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

         void set(value_type __value)
         {
            value(__value);
         }

         value_type get() const
         {
            return value();
         }

         value_type value() const
         {
            return helper.data;
         }

         void value(value_type __value)
         {
            helper.data = __value;
         }

         HF::Interface const *owner() const
         {
            return _owner;
         }

         uint16_t size(bool with_uid) const
         {
            return size() + (with_uid ? sizeof(uint8_t) : 0);
         }

         uint16_t size() const
         {
            return helper.size();
         }

         uint16_t pack(Common::ByteArray &array, uint16_t offset, bool with_uid) const
         {
            HF_SERIALIZABLE_CHECK(array, offset, size(with_uid));

            uint16_t start = offset;

            if (with_uid)
            {
               offset += array.write(offset, uid());
            }

            offset += helper.pack(array, offset);

            return offset - start;
         }

         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
         {
            return helper.pack(array, offset);
         }

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset, bool with_uid)
         {
            HF_SERIALIZABLE_CHECK(array, offset, size(with_uid));

            uint16_t start = offset;

            if (with_uid)
            {
               uint8_t temp;
               offset += array.read(offset, temp);

               if (temp != uid())
               {
                  return 0;
               }
            }

            offset += helper.unpack(array, offset);

            return offset - start;
         }

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

         IAttribute *clone() const
         {
            return new HF::Attributes::Attribute<T>(this->_itf_uid, this->_uid, this->_owner,
                                                    this->helper.data, this->_writable);
         }

         int compare(const IAttribute &other) const
         {
            int res = AbstractAttribute::compare(other);

            if (res == 0)
            {
               Attribute<T> *temp = (Attribute<T> *) & other;
               res = helper.compare(temp->helper);
            }

            return res;
         }

         float changed(const IAttribute &other) const
         {
            int res = AbstractAttribute::compare(other);

            if (res == 0)
            {
               Attribute<T> *temp = (Attribute<T> *) & other;
               return helper.changed(temp->helper);
            }

            return 0.0;
         }

         protected:

         Common::SerializableHelper<T> helper;

         const HF::Interface           *_owner;

         private:

         // Don't allow copy.
         Attribute(const Attribute &other) = delete;
      };

      template<typename T, typename _Owner>
      struct Attribute<T, _Owner, EnableIf(IsParent(HF::Interface, _Owner))>:
         public AbstractAttribute
      {
         typedef typename std::remove_reference<T>::type value_type;

         typedef typename std::function<value_type(_Owner &)> getter_t;
         typedef typename std::function<void (_Owner &, T)> setter_t;

         Attribute(_Owner &__owner, const uint8_t uid, getter_t _getter, setter_t _setter,
                   bool writable = false):
            AbstractAttribute(__owner.uid(), uid, writable), _owner(&__owner), getter(_getter),
            setter(_setter)
         {}

         Attribute(_Owner &__owner, const uint8_t uid, getter_t _getter, bool writable = false):
            AbstractAttribute(__owner.uid(), uid, writable), _owner(&__owner), getter(_getter)
         {}

         __attribute__((__nonnull__(2)))
         Attribute(_Owner *__owner, const uint8_t uid, getter_t _getter, setter_t _setter,
                   bool writable = false):
            AbstractAttribute(__owner->uid(), uid, writable), _owner(__owner), getter(_getter),
            setter(_setter)
         {}

         __attribute__((__nonnull__(2)))
         Attribute(_Owner *__owner, const uint8_t uid, getter_t _getter, bool writable = false):
            AbstractAttribute(__owner->uid(), uid, writable), _owner(__owner), getter(_getter)
         {}

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

         void set(value_type __value)
         {
            value(__value);
         }

         value_type get() const
         {
            return value();
         }

         value_type value() const
         {
            return getter(*_owner);
         }

         void value(value_type __value)
         {
            if (setter)
            {
               setter(*_owner, __value);
            }
         }

         HF::Interface const *owner() const
         {
            return _owner;
         }

         uint16_t size(bool with_uid) const
         {
            return size() + (with_uid ? sizeof(uint8_t) : 0);
         }

         uint16_t size() const
         {
            Common::SerializableHelper<value_type> helper(value());
            return helper.size();
         }

         uint16_t pack(Common::ByteArray &array, uint16_t offset, bool with_uid) const
         {
            HF_SERIALIZABLE_CHECK(array, offset, size(with_uid));

            uint16_t start = offset;

            if (with_uid)
            {
               offset += array.write(offset, uid());
            }

            Common::SerializableHelper<value_type> helper(value());

            offset += helper.pack(array, offset);

            return offset - start;
         }

         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
         {
            Common::SerializableHelper<value_type> helper(value());

            return helper.pack(array, offset);
         }

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset, bool with_uid)
         {
            HF_SERIALIZABLE_CHECK(array, offset, size(with_uid));

            Common::SerializableHelper<value_type> helper;
            uint16_t start = offset;

            if (with_uid)
            {
               uint8_t temp;
               offset += array.read(offset, temp);

               if (temp != uid())
               {
                  goto _end;
               }
            }

            offset += helper.unpack(array, offset);

            setter(*_owner, helper.data);

            _end:
            return offset - start;
         }

         uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
         {
            Common::SerializableHelper<value_type> helper;
            uint16_t result = helper.unpack(array, offset);

            setter(*_owner, helper.data);
            return result;
         }

         IAttribute *clone() const
         {
            return new HF::Attributes::Attribute<T, _Owner>(this->_owner, this->uid(),
                                                            this->getter, this->setter,
                                                            this->isWritable());
         }

         int compare(const IAttribute &other) const
         {
            int res = AbstractAttribute::compare(other);

            if (res == 0)
            {
               Common::SerializableHelper<value_type> lhs(value());
               Common::SerializableHelper<value_type> rhs(((Attribute<T> *) & other)->value());

               res = lhs.compare(rhs);
            }

            return res;
         }

         float changed(const IAttribute &other) const
         {
            int res = AbstractAttribute::compare(other);

            if (res == 0)
            {
               Common::SerializableHelper<value_type> lhs(value());
               Common::SerializableHelper<value_type> rhs(((Attribute<T> *) & other)->value());

               return lhs.changed(rhs);
            }

            return 0.0;
         }

         protected:

         _Owner   *_owner;
         getter_t getter;
         setter_t setter;

         private:

         // Don't allow copy.
         Attribute(const Attribute &other) = delete;
      };

      struct List: public std::list<IAttribute *>
      {
         IAttribute *operator[](uint8_t uid) const
         {
            for (const_iterator it = begin(); it != end(); ++it)
            {
               if ((*it)->uid() == uid)
               {
                  return *it;
               }
            }

            return nullptr;
         }
      };

      struct Response: public Protocol::Response
      {
         IAttribute *attribute;

         Response(IAttribute *_attribute = nullptr):
            attribute(_attribute)
         {}

         virtual ~Response()
         {
            delete attribute;
         }

         uint16_t size() const
         {
            return Protocol::Response::size() + (attribute != nullptr ? attribute->size() : 0);
         }

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

            uint16_t start = offset;

            offset += Protocol::Response::pack(array, offset);

            offset += (attribute != nullptr ? attribute->pack(array, offset) : 0);

            return offset - start;
         }

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

            uint16_t start = offset;

            offset += Protocol::Response::unpack(array, offset);
            offset += (attribute != nullptr ? attribute->unpack(array, offset) : 0);

            return offset - start;
         }
      };

      typedef enum _Pack
      {
         MANDATORY = 0x00, 
         ALL       = 0xFE, 
         DYNAMIC   = 0xFF, 
      } Pack;

      List get(const HF::Interface &itf, uint8_t pack_id, const UIDS &uids);

      template<typename T>
      Attribute<T> *adapt(IAttribute *attr)
      {
         return static_cast<Attribute<T> *>(attr);
      }

      template<typename T>
      const Attribute<T> *adapt(const IAttribute *attr)
      {
         return static_cast<const Attribute<T> *>(attr);
      }

   }  // namespace Attributes

   namespace Protocol
   {
      namespace GetAttributePack
      {
         struct Request
         {
            HF::Attributes::UIDS attributes; 

            uint8_t count;

            Request(): count(0) {}

            Request(HF::Attributes::UIDS &attributes):
               attributes(attributes), count(0)
            {}

            uint16_t size() const
            {
               return attributes.size();
            }

            uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
            {
               return attributes.pack(array, offset);
            }

            uint16_t unpack(const Common::ByteArray &array, uint16_t offset = 0)
            {
               return attributes.unpack(array, offset, count);
            }
         };

         struct Response: public Protocol::Response
         {
            HF::Attributes::Factory attribute_factory;

            HF::Attributes::List attributes;

            uint8_t count;

            Response(): attribute_factory(nullptr)
            {}

            Response(HF::Attributes::List &attributes):
               attribute_factory(nullptr), attributes(attributes)
            {}

            Response(HF::Attributes::Factory factory):
               attribute_factory(factory)
            {}

            virtual ~Response()
            {
               /* *INDENT-OFF* */
               std::for_each (attributes.begin (), attributes.end (),
                               [](HF::Attributes::IAttribute *attr)
               {
                  delete attr;
               });
               /* *INDENT-ON* */
            }

            static constexpr uint16_t min_size = Protocol::Response::min_size // General response.
                                                 + sizeof(uint8_t);           // Number of attributes.

            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);
         };

      } // namespace GetAttributePack

      namespace SetAttributePack
      {
         struct Request
         {
            HF::Attributes::List attributes; 

            uint8_t count;

            virtual ~Request();

            static constexpr uint16_t min_size = sizeof(uint8_t);    // Number of attributes.

            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 Response
         {
            struct Result
            {
               uint8_t        uid;  
               Common::Result code; 

               Result() {}

               Result(uint8_t uid, Common::Result code):
                  uid(uid), code(code)
               {}

               static constexpr uint16_t min_size = sizeof(uint8_t) + sizeof(uint8_t);

               uint16_t size() const
               {
                  return min_size;
               }

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

                  offset += array.write(offset, (uint8_t) uid);

                  array.write(offset, (uint8_t) code);

                  return min_size;
               }

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

                  offset += array.read(offset, uid);

                  uint8_t temp;
                  array.read(offset, temp);
                  code = static_cast<Common::Result>(temp);

                  return min_size;
               }
            };

            typedef std::vector<Result> results_t;

            results_t results;   

            uint8_t count;

            static constexpr uint16_t min_size = sizeof(uint8_t); // Number of attribute results.

            uint16_t size() const
            {
               uint16_t result = min_size;

               result += results.size() * Result::min_size;

               return result;
            }

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

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

      } // namespace SetAttributePack
   }  // namespace Protocol

}  // namespace HF

#endif /* HF_ATTRIBUTES_H */