Observers.h

Go to the documentation of this file.

 
#ifndef OBSERVERS_H_INCLUDED
#define OBSERVERS_H_INCLUDED
 
#include <Arduino.h>
#include "../Definitions.h"
 
namespace Coap
{
 
    class Observer
    {
    private:
        bool _active : 8;
 
        IPAddress _ip;
        uint16_t _port = 0;
        uint8_t _token[COAP_MAX_TOKEN_LENGTH] = {0};
        uint8_t _tokenLength = 0;
 
    public:
        Observer() : _active(false) {}
 
        Observer(IPAddress ip, uint16_t port, const uint8_t *token, uint8_t tokenLength)
            : _active(true), _ip(ip), _port(port), _tokenLength(tokenLength)
        {
            // Copy the token value, ensuring that we do not exceed the maximum token length.
            memcpy(this->_token, token, tokenLength > COAP_MAX_TOKEN_LENGTH ? COAP_MAX_TOKEN_LENGTH : tokenLength);
        }
 
        bool isActive() const
        {
            return this->_active;
        }
 
        void setActive(bool active)
        {
            this->_active = active;
        }
 
        IPAddress getIp() const
        {
            return this->_ip;
        }
 
        uint16_t getPort() const
        {
            return this->_port;
        }
 
        const uint8_t *getToken() const
        {
            return this->_token;
        }
 
        uint8_t getTokenLength() const
        {
            return this->_tokenLength;
        }
 
        uint32_t getNextSequentialNumber()
        {
            unsigned long currentTime = millis();
            return currentTime & 0xFFFFFF; // Return only the least significant 24 bits.
        }
    };
 
    template <size_t N>
    class ObserverRegistry
    {
    private:
        Observer _observers[N];
 
    public:
        Observer &operator[](size_t index)
        {
            return _observers[index];
        }
 
        const Observer &operator[](size_t index) const
        {
            return _observers[index];
        }
 
        size_t length() const
        {
            return N;
        }
 
        ErrorCode add(IPAddress ip, uint16_t port, const uint8_t *token, uint8_t tokenLength)
        {
            // We MUST check if the observer is already present before trying to add it, to avoid duplicates.
            for (size_t i = 0; i < N; i++)
            {
                if (!this->_observers[i].isActive())
                    continue; // Skip inactive observers.
 
                // An observer is considered the same if it matches the combination of IP address, port, token and token length.
                if (this->_observers[i].getIp() == ip &&
                    this->_observers[i].getPort() == port &&
                    this->_observers[i].getTokenLength() == tokenLength &&
                    memcmp(this->_observers[i].getToken(), token, tokenLength) == 0)
                {
                    // Matching active observer found. No need to add again.
                    return ErrorCode::OK;
                }
            }
 
            // New observer.
            // Find the first inactive observer slot and add the new observer there.
            for (size_t i = 0; i < N; i++)
            {
                if (!this->_observers[i].isActive())
                {
                    // Inactive slot found. Add the new observer here (active by default, see constructor).
                    this->_observers[i] = Observer(ip, port, token, tokenLength);
                    return ErrorCode::OK;
                }
            }
 
            return ErrorCode::NOT_SUPPORTED;
        }
 
        ErrorCode remove(IPAddress ip, uint16_t port, const uint8_t *token, uint8_t tokenLength)
        {
            // Find the observer matching the given parameters and remove it.
            for (size_t i = 0; i < N; i++)
            {
                if (!this->_observers[i].isActive())
                    continue; // Skip inactive observers.
                if (this->_observers[i].getIp() == ip &&
                    this->_observers[i].getPort() == port &&
                    this->_observers[i].getTokenLength() == tokenLength &&
                    memcmp(this->_observers[i].getToken(), token, tokenLength) == 0)
                {
                    // Matching observer found. Remove it by marking it as inactive.
                    this->_observers[i].setActive(false);
                    return ErrorCode::OK;
                }
            }
            return ErrorCode::NOT_FOUND;
        }
 
        ErrorCode remove(const Observer &observer)
        {
            return this->remove(observer.getIp(), observer.getPort(), observer.getToken(), observer.getTokenLength());
        }
    };
}
 
#endif // OBSERVERS_H_INCLUDED