layers_dummy.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
 
#include "spsp/layers.hpp"
#include "spsp/local_addr.hpp"
#include "spsp/local_message.hpp"
 
namespace SPSP::LocalLayers
{
    class DummyLocalLayer : public ILocalLayer<LocalMessage<LocalAddr>>
    {
    public:
        using LocalAddrT = SPSP::LocalAddr;
        using LocalMessageT = SPSP::LocalMessage<SPSP::LocalAddr>;
        using SentMsgsSetT = std::unordered_set<LocalMessageT>;
 
    protected:
        SentMsgsSetT m_sentMsgs;
        size_t m_sentMsgsCount = 0;
 
    public:
        virtual bool send(const LocalMessageT& msg)
        {
            m_sentMsgs.insert(msg);
            m_sentMsgsCount++;
            return true;
        }
 
        void receiveDirect(const LocalMessageT& msg, int rssi = 0)
        {
            if (this->nodeConnected()) {
                this->getNode()->receiveLocal(msg, rssi);
            }
        }
 
        const SentMsgsSetT& getSentMsgs()
        {
            return m_sentMsgs;
        }
 
        size_t getSentMsgsCount()
        {
            return m_sentMsgsCount;
        }
    };
} // namespace SPSP::LocalLayers
 
namespace SPSP::FarLayers
{
    class DummyFarLayer : public IFarLayer
    {
    public:
        using PubsSetT = std::unordered_set<std::string>;  // not using tuple, because plain string if simpler
        using SubsSetT = std::unordered_set<std::string>;
        using SubsLogT = std::vector<std::string>;
 
    protected:
        PubsSetT m_pubs;
        SubsSetT m_subs;
        SubsLogT m_subsLog;
        SubsLogT m_unsubsLog;
 
    public:
        virtual bool publish(const std::string& src, const std::string& topic,
                             const std::string& payload)
        {
            // `LocalMessage.toString()`-compatible string
            m_pubs.insert("PUB " + src + " " + topic + " " + payload);
            return true;
        }
 
        virtual bool subscribe(const std::string& topic)
        {
            m_subs.insert(topic);
            m_subsLog.push_back(topic);
            return true;
        }
 
        virtual bool unsubscribe(const std::string& topic)
        {
            m_unsubsLog.push_back(topic);
            return m_subs.erase(topic);
        }
 
        virtual void receiveDirect(const std::string& topic,
                                   const std::string& payload)
        {
            if (this->nodeConnected()) {
                this->getNode()->receiveFar(topic, payload);
            }
        }
 
        const PubsSetT& getPubs()
        {
            return m_pubs;
        }
 
        const SubsSetT& getSubs()
        {
            return m_subs;
        }
 
        const SubsLogT& getSubsLog()
        {
            return m_subsLog;
        }
 
        const SubsLogT& getUnsubsLog()
        {
            return m_unsubsLog;
        }
    };
} // namespace SPSP::FarLayers