uids.h

Go to the documentation of this file.

// =============================================================================
// =============================================================================
#ifndef HF_UIDS_H
#define HF_UIDS_H

#include "hanfun/common.h"

namespace HF
{
   // =============================================================================
   // UID implementation
   // =============================================================================

   namespace UID
   {
      typedef enum _Type
      {
         NONE_UID = 0x00,   
         DECT_UID = 0x01,   
         MAC_UID  = 0x02,   
         URI_UID  = 0x03,   
      } Type;

      struct UID_T: public Common::Serializable, public Common::Cloneable<UID_T>
      {
         virtual uint8_t type() const = 0;

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

         bool operator!=(const UID_T &other) const
         {
            return !(*this == other);
         }

         virtual int compare(const UID_T &other) const
         {
            return (this->type() - other.type());
         }

         static constexpr uint16_t min_size = sizeof(uint8_t)     // UID Type.
                                              + sizeof(uint8_t);  // Size of the UID.

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

            array.write(offset, this->type());

            return sizeof(uint8_t);
         }

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

            uint8_t type;
            array.read(offset, type);

            assert((type & (~0x80)) == this->type());

            return sizeof(uint8_t);
         }
      };

      template<uint8_t _type>
      struct Abstract: public UID_T
      {
         uint8_t type() const
         {
            return _type;
         }
      };

      struct NONE: public Abstract<NONE_UID>
      {
         uint16_t pack(Common::ByteArray &array, uint16_t offset = 0) const
         {
            HF_SERIALIZABLE_CHECK(array, offset, min_size);

            offset += UID_T::pack(array, offset);

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

            return min_size;
         }

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

            uint16_t res = UID_T::unpack(array, offset);

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

            offset += res;

            uint8_t size;
            array.read(offset, size);

            assert(size == 0);

            return min_size;
         }

         NONE *clone() const
         {
            return new NONE(*this);
         }
      };

      template<typename _Class, uint8_t _size, uint8_t _type>
      class ByteArray: public Abstract<_type>
      {
         protected:

         uint8_t value[_size];

         public:

         ByteArray(): Abstract<_type>() {}

         ByteArray(uint8_t _value[_size]): Abstract<_type>()
         {
            memcpy(value, _value, _size * sizeof(uint8_t));
         }

         ByteArray(uint8_t _value): Abstract<_type>()
         {
            memset(value, _value, _size * sizeof(uint8_t));
         }

         static constexpr uint16_t min_size = UID_T::min_size + _size;

         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 += Abstract<_type>::pack(array, offset);

            offset += array.write(offset, (uint8_t) sizeof(value));

            for (uint8_t i = 0; i < sizeof(value); i++)
            {
               offset += array.write(offset, value[i]);
            }

            return min_size;
         }

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

            offset += Abstract<_type>::unpack(array, offset);

            uint8_t size;
            offset += array.read(offset, size);

            assert(size == sizeof(value));

            if (size != sizeof(value))
            {
               return 0;
            }

            for (uint8_t i = 0; i < size; i++)
            {
               offset += array.read(offset, value[i]);
            }

            return min_size;
         }

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

         int compare(const UID_T &other) const
         {
            int res = Abstract<_type>::compare(other);

            return (res ==
                    0 ? memcmp(value, ((_Class *) &other)->value, sizeof(value)) : res);
         }

         // =============================================================================
         // Array style API.
         // =============================================================================

         uint8_t const &operator[](uint16_t index) const
         {
            return value[index];
         }

         uint8_t &operator[](uint16_t index)
         {
            return value[index];
         }

         uint8_t const &at(uint16_t index) const
         {
            assert(index < _size);
            return value[index];
         }

         uint8_t &at(uint16_t index)
         {
            assert(index < _size);
            return value[index];
         }

         // =============================================================================
         // Helper API
         // =============================================================================

         void fill(uint8_t byte)
         {
            memset(value, byte, sizeof(value));
         }

         void clear()
         {
            memset(value, 0, sizeof(value));
         }

         static uint16_t length()
         {
            return _size;
         }
      };

      struct DECT: public ByteArray<DECT, 5, DECT_UID>
      {
         constexpr static uint8_t SIZE = 5;

         DECT(): ByteArray<DECT, 5, DECT_UID>(0xFF)
         {}

         DECT(uint8_t _value[5]): ByteArray<DECT, 5, DECT_UID>(_value)
         {}

         // ===================================================================
         // Cloneable
         // ===================================================================

         DECT *clone() const
         {
            return new DECT(*this);
         }
      };

      struct MAC: public ByteArray<MAC, 6, MAC_UID>
      {
         constexpr static uint8_t SIZE = 6;

         MAC(): ByteArray<MAC, 6, MAC_UID>()
         {}

         MAC(uint8_t _value[6]): ByteArray<MAC, 6, MAC_UID>(_value)
         {}

         // ===================================================================
         // Cloneable
         // ===================================================================

         MAC *clone() const
         {
            return new MAC(*this);
         }
      };

      struct URI: public Abstract<URI_UID>
      {
         std::string value;

         URI()
         {}

         URI(const std::string &value):
            value(value)
         {}

         uint16_t size() const
         {
            return Abstract<URI_UID>::size() + value.size();
         }

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

            uint16_t start = offset;

            offset += Abstract<URI_UID>::pack(array, offset);

            assert(value.size() <= 0xFF);
            offset += array.write(offset, (uint8_t) value.size());

            for (uint8_t i = 0; i < value.size(); i++)
            {
               offset += array.write(offset, (uint8_t) value[i]);
            }

            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 += Abstract<URI_UID>::unpack(array, offset);

            uint8_t size;
            offset += array.read(offset, size);

            HF_SERIALIZABLE_CHECK(array, offset, size);

            value = std::string(size, 0);

            for (uint8_t i = 0; i < size; i++)
            {
               uint8_t c;
               offset  += array.read(offset, c);
               value[i] = c;
            }

            return offset - start;
         }

         // ===================================================================
         // Cloneable
         // ===================================================================

         URI *clone() const
         {
            return new URI(*this);
         }

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

         int compare(const UID_T &other) const
         {
            int res = Abstract<URI_UID>::compare(other);

            return (res == 0 ? value.compare(((URI *) &other)->value) : res);
         }

         std::string str() const
         {
            return value;
         }
      };

      class UID: public HF::Common::Serializable
      {
         UID_T *_raw;

         bool owner;

         public:

         UID(): _raw(new NONE()), owner(true)
         {}

         UID(UID_T *_uid, bool _owner = false):
            _raw(_uid), owner(_owner)
         {
            assert(_uid != nullptr);
         }

         UID(UID &&other): _raw(other._raw), owner(other.owner)
         {
            other.owner = false;
         }

         UID(const UID &other): _raw(other._raw->clone()), owner(true)
         {}

         virtual ~UID()
         {
            if (owner)
            {
               delete _raw;
            }
         }

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

         uint8_t type() const
         {
            return _raw->type();
         }

         bool operator==(const UID &other) const
         {
            return (this->_raw->compare(*(other._raw)) == 0);
         }

         bool operator!=(const UID &other) const
         {
            return !(*this == other);
         }

         uint16_t size() const
         {
            return _raw->size();
         }

         uint16_t pack(Common::ByteArray &array, uint16_t offset) const
         {
            return _raw->pack(array, offset);
         }

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

         // =============================================================================
         // Utils
         // =============================================================================

         UID &operator=(const UID &other)
         {
            // Ship if same object.
            if (this == &other)
            {
               return *this;
            }

            // Delete current wrapped object if owner.
            if (this->owner)
            {
               delete this->_raw;
            }

            // Clone wrapped UID_T and take ownership of the clone.
            this->_raw  = other._raw->clone();
            this->owner = true;

            return *this;
         }

         UID &operator=(UID &&other)
         {
            std::swap(this->_raw, other._raw);
            std::swap(this->owner, other.owner);

            return *this;
         }

         UID &operator=(UID_T *_uid)
         {
            if (owner)
            {
               delete this->_raw;
            }

            _raw  = _uid;
            owner = true;

            return *this;
         }

         int compare(const UID &other) const
         {
            return _raw->compare(*(other._raw));
         }

         int compare(const UID_T &other) const
         {
            return _raw->compare(other);
         }

         UID_T const *raw() const
         {
            return _raw;
         }

         float changed(const UID &other) const
         {
            UNUSED(other);
            return 0.0;
         }
      };

   }  // namespace UID

}  // namespace HF

// =============================================================================
// Helper Functions
// =============================================================================

inline bool operator==(const HF::UID::UID &lhs, const HF::UID::UID_T &rhs)
{
   return (lhs.compare(rhs) == 0);
}

inline bool operator==(const HF::UID::UID_T &lhs, const HF::UID::UID &rhs)
{
   return (rhs.compare(lhs) == 0);
}

inline bool operator!=(const HF::UID::UID &lhs, const HF::UID::UID_T &rhs)
{
   return !(lhs == rhs);
}

inline bool operator!=(const HF::UID::UID_T &lhs, const HF::UID::UID &rhs)
{
   return !(lhs == rhs);
}

std::ostream &operator<<(std::ostream &stream, const HF::UID::UID &uid);

#endif /* HF_UIDS_H */