SharingEntity.hpp

#pragma once
 
#include "containers/ClauseExchange.hpp"
#include "utils/Logger.hpp"
#include "utils/Parameters.hpp"
 
#include <atomic>
#include <memory>
#include <mutex>
#include <set>
#include <shared_mutex>
 
class SharingEntity : public std::enable_shared_from_this<SharingEntity>
{
  public:
    SharingEntity()
        : m_sharingId(s_currentSharingId.fetch_add(1))
        , m_clients(0)
    {
        LOGDEBUG1("I am sharing entity %d", m_sharingId);
    }
 
    SharingEntity(const std::vector<std::shared_ptr<SharingEntity>>& clients)
        : m_sharingId(s_currentSharingId.fetch_add(1))
        , m_clients(clients.begin(), clients.end())
    {
        LOGDEBUG1("I am sharing entity %d", m_sharingId);
    }
 
    virtual ~SharingEntity() {}
 
    virtual bool importClause(const ClauseExchangePtr& clause) = 0;
 
    virtual void importClauses(const std::vector<ClauseExchangePtr>& v_clauses) = 0;
 
    int getSharingId() const { return this->m_sharingId; }
 
    void setSharingId(int _id) { this->m_sharingId = _id; }
 
    virtual void addClient(std::shared_ptr<SharingEntity> client)
    {
        std::unique_lock<std::shared_mutex> lock(m_clientsMutex);
        LOGDEBUG3("Sharing Entity %d: new client %p (counts: %d)", m_sharingId, client.get(), client.use_count());
        m_clients.push_back(client);
    }
 
 
    virtual void removeClient(std::shared_ptr<SharingEntity> client)
    {
        std::unique_lock<std::shared_mutex> lock(m_clientsMutex);
        auto initialSize = m_clients.size();
        m_clients.erase(
            std::remove_if(m_clients.begin(),
                           m_clients.end(),
                           [&client](const std::weak_ptr<SharingEntity>& wp) { return wp.lock() == client; }),
            m_clients.end());
        if (m_clients.size() < initialSize) {
            LOGDEBUG3("Sharing Entity %d: removed client %p", m_sharingId, client.get());
        }
    }
 
    size_t getClientCount() const
    {
        std::shared_lock<std::shared_mutex> lock(m_clientsMutex);
        return m_clients.size();
    }
 
    void clearClients()
    {
        std::unique_lock<std::shared_mutex> lock(m_clientsMutex);
        m_clients.clear();
    }
 
  protected:
    virtual bool exportClauseToClient(const ClauseExchangePtr& clause, std::shared_ptr<SharingEntity> client)
    {
        return client->importClause(clause);
    }
 
    bool exportClause(const ClauseExchangePtr& clause)
    {
        std::shared_lock<std::shared_mutex> lock(m_clientsMutex);
        bool exported = false;
        for (const auto& client : m_clients) {
            if (auto sharedClient = client.lock()) {
                if (exportClauseToClient(clause, sharedClient))
                    exported = true;
            }
        }
        return exported;
    }
 
    void exportClauses(const std::vector<ClauseExchangePtr>& clauses)
    {
        std::shared_lock<std::shared_mutex> lock(m_clientsMutex);
        for (const auto& weakClient : m_clients) {
            if (auto client = weakClient.lock()) {
                for (const ClauseExchangePtr& clause : clauses) {
                    exportClauseToClient(clause, client);
                }
            }
        }
    }
 
  private:
    int m_sharingId;
 
    inline static std::atomic<int> s_currentSharingId{ 0 };
 
  protected:
    std::vector<std::weak_ptr<SharingEntity>> m_clients;
 
    mutable std::shared_mutex m_clientsMutex;
};