connection_handle.h

Go to the documentation of this file.

/*
  This file is part of KDBindings.
 
  SPDX-FileCopyrightText: 2021 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
  Author: Sean Harmer <sean.harmer@kdab.com>
 
  SPDX-License-Identifier: MIT
 
  Contact KDAB at <info@kdab.com> for commercial licensing options.
*/
 
#pragma once
 
#include <kdbindings/genindex_array.h>
#include <kdbindings/utils.h>
#include <memory>
 
namespace KDBindings {
 
template<typename... Args>
class Signal;
 
class ConnectionHandle;
 
namespace Private {
//
// This class defines a virtual interface, that the Signal this ConnectionHandle refers
// to must implement.
// It allows ConnectionHandle to refer to this non-template class, which then dispatches
// to the template implementation using virtual function calls.
// It allows ConnectionHandle to be a non-template class.
class SignalImplBase : public std::enable_shared_from_this<SignalImplBase>
{
public:
    SignalImplBase() = default;
 
    virtual ~SignalImplBase() = default;
 
    virtual void disconnect(const ConnectionHandle &handle) noexcept = 0;
    virtual bool blockConnection(const GenerationalIndex &id, bool blocked) = 0;
    virtual bool isConnectionActive(const GenerationalIndex &id) const noexcept = 0;
    virtual bool isConnectionBlocked(const GenerationalIndex &id) const = 0;
};
 
} // namespace Private
 
class ConnectionHandle
{
public:
    ConnectionHandle() = default;
 
    ConnectionHandle(const ConnectionHandle &) noexcept = default;
    ConnectionHandle &operator=(const ConnectionHandle &) noexcept = default;
 
    ConnectionHandle(ConnectionHandle &&) noexcept = default;
    ConnectionHandle &operator=(ConnectionHandle &&) noexcept = default;
 
    void disconnect() noexcept
    {
        if (auto shared_impl = checkedLock()) {
            shared_impl->disconnect(*this);
        }
 
        // ConnectionHandle is no longer active;
        m_signalImpl.reset();
    }
 
    bool isActive() const
    {
        return static_cast<bool>(checkedLock());
    }
 
    bool block(bool blocked)
    {
        if (auto shared_impl = checkedLock()) {
            return shared_impl->blockConnection(*m_id, blocked);
        }
        throw std::out_of_range("Cannot block a non-active connection!");
    }
 
    bool isBlocked() const
    {
        if (auto shared_impl = checkedLock()) {
            return shared_impl->isConnectionBlocked(*m_id);
        }
        throw std::out_of_range("Cannot check whether a non-active connection is blocked!");
    }
 
    template<typename... Args>
    bool belongsTo(const Signal<Args...> &signal) const
    {
        auto shared_impl = m_signalImpl.lock();
        return shared_impl && shared_impl == std::static_pointer_cast<Private::SignalImplBase>(signal.m_impl);
    }
 
    // Define an operator== function to compare ConnectionHandle objects.
    bool operator==(const ConnectionHandle &other) const
    {
        auto thisSignalImpl = m_signalImpl.lock();
        auto otherSignalImpl = other.m_signalImpl.lock();
 
        // If both signalImpl pointers are valid, compare them along with the IDs.
        if (thisSignalImpl && otherSignalImpl) {
            return (thisSignalImpl == otherSignalImpl) && (m_id == other.m_id);
        }
 
        // If neither instance has an ID, and both signalImpl pointers are invalid, consider them equal.
        if (!m_id.has_value() && !other.m_id.has_value() && !thisSignalImpl && !otherSignalImpl) {
            return true;
        }
 
        // In all other cases, they are not equal.
        return false;
    }
 
    void release() const { }
 
private:
    template<typename...>
    friend class Signal;
 
    std::weak_ptr<Private::SignalImplBase> m_signalImpl;
    std::optional<Private::GenerationalIndex> m_id;
 
    // private, so it is only available from Signal
    ConnectionHandle(std::weak_ptr<Private::SignalImplBase> signalImpl, std::optional<Private::GenerationalIndex> id)
        : m_signalImpl{ std::move(signalImpl) }, m_id{ std::move(id) }
    {
    }
    void setId(const Private::GenerationalIndex &id)
    {
        m_id = id;
    }
 
    // Checks that the weak_ptr can be locked and that the connection is
    // still active
    std::shared_ptr<Private::SignalImplBase> checkedLock() const noexcept
    {
        if (m_id.has_value()) {
            auto shared_impl = m_signalImpl.lock();
            if (shared_impl && shared_impl->isConnectionActive(*m_id)) {
                return shared_impl;
            }
        }
        return nullptr;
    }
};
 
class ScopedConnection
{
public:
    ScopedConnection() = default;
 
    ScopedConnection(ScopedConnection &&) noexcept = default;
 
    ScopedConnection(const ScopedConnection &) = delete;
    ScopedConnection &operator=(const ScopedConnection &) = delete;
 
    ScopedConnection &operator=(ScopedConnection &&other) noexcept
    {
        m_connection.disconnect();
        m_connection = std::move(other.m_connection);
        return *this;
    }
 
    ScopedConnection(ConnectionHandle &&h) noexcept
        : m_connection(std::move(h))
    {
    }
 
    ScopedConnection &operator=(ConnectionHandle &&h) noexcept
    {
        return *this = ScopedConnection(std::move(h));
    }
 
    ConnectionHandle &handle()
    {
        return m_connection;
    }
 
    const ConnectionHandle &handle() const
    {
        return m_connection;
    }
 
    ConnectionHandle *operator->()
    {
        return &m_connection;
    }
 
    const ConnectionHandle *operator->() const
    {
        return &m_connection;
    }
 
    ~ScopedConnection() noexcept
    {
        m_connection.disconnect();
    }
 
private:
    ConnectionHandle m_connection;
};
 
} // namespace KDBindings