Observers.h

Go to the documentation of this file.

 
#ifndef OBSERVERS_H_INCLUDED
#define OBSERVERS_H_INCLUDED
 
#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;
        unsigned long _lastSeen = 0;
 
    public:
        Observer() : _active(false) {}
 
        Observer(IPAddress ip, uint16_t port, const uint8_t *token, uint8_t tokenLength)
            : _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);
            this->activate();
        }
 
        bool isActive() const
        {
            return this->_active;
        }
 
        bool isStale() const;
 
        void activate();
 
        void deactivate();
 
        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();
    };
 
    template <size_t N>
    class ObserverRegistry
    {
        // Ensure N is at least 1.
        static_assert(N >= 1, "ObserverRegistry Error: N must be 1 or greater!");
 
    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;
        }
 
        size_t countActive() const
        {
            size_t count = 0;
            for (size_t i = 0; i < N; i++)
            {
                if (this->_observers[i].isActive())
                    count++;
            }
            return count;
        }
 
        ErrorCode add(IPAddress ip, uint16_t port, const uint8_t *token, uint8_t tokenLength)
        {
            Observer new_observer(ip, port, token, tokenLength);
            return this->add(new_observer);
        }
 
        ErrorCode add(Observer observer)
        {
            if (!observer.isActive())
            {
                // Inactive observer cannot be added to the registry.
                return ErrorCode::INVALID_ARGUMENT;
            }
 
            // 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() == observer.getIp() &&
                    this->_observers[i].getPort() == observer.getPort() &&
                    this->_observers[i].getTokenLength() == observer.getTokenLength() &&
                    memcmp(this->_observers[i].getToken(), observer.getToken(), observer.getTokenLength()) == 0)
                {
                    // Matching active observer found. No need to add it 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.
                    this->_observers[i] = observer;
                    return ErrorCode::OK;
                }
            }
            // Could not find an inactive slot, the registry is full.
            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].deactivate();
                    return ErrorCode::OK;
                }
            }
            return ErrorCode::NOT_FOUND;
        }
 
        ErrorCode remove(IPAddress ip, uint16_t port)
        {
            ErrorCode result = ErrorCode::NOT_FOUND;
            // 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)
                {
                    // Matching observer found. Remove it by marking it as inactive.
                    this->_observers[i].deactivate();
                    result = ErrorCode::OK;
                }
            }
            return result;
        }
 
        ErrorCode remove(IPAddress ip)
        {
            ErrorCode result = ErrorCode::NOT_FOUND;
            // 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)
                {
                    // Matching observer found. Remove it by marking it as inactive.
                    this->_observers[i].deactivate();
                    result = ErrorCode::OK;
                }
            }
            return result;
        }
 
        ErrorCode remove(const Observer &observer)
        {
            return this->remove(observer.getIp(), observer.getPort(), observer.getToken(), observer.getTokenLength());
        }
 
        ErrorCode removeStale()
        {
            for (size_t i = 0; i < N; i++)
            {
                if (this->_observers[i].isActive() && this->_observers[i].isStale())
                {
                    this->_observers[i].deactivate();
                }
            }
            return ErrorCode::OK;
        }
    };
}
 
#endif // OBSERVERS_H_INCLUDED