ServiceRegistry.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac

    This file is part of Leosac.

    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once
#include "tools/JSONUtils.hpp"
#include "tools/bs2.hpp"
#include "tools/log.hpp"
#include "tools/registry/Registry.hpp"
#include <boost/type_index.hpp>

namespace Leosac
{

namespace service_event
{
enum EventType
{
    REGISTERED,
    UNREGISTERED,
};
class Event
{
  public:
    Event(EventType t)
        : type_(t)
    {
    }
    virtual ~Event() = default;
    EventType type() const
    {
        return type_;
    }

  private:
    EventType type_;
};

class ServiceRegistered : public Event
{
  public:
    ServiceRegistered(const boost::typeindex::type_index &interface_type)
        : Event(EventType::REGISTERED)
        , service_interface_type_(interface_type)
    {
    }
    boost::typeindex::type_index interface_type() const
    {
        return service_interface_type_;
    }

  private:
    boost::typeindex::type_index service_interface_type_;
};

class ServiceUnregistered : public Event
{
  public:
    ServiceUnregistered(const boost::typeindex::type_index &interface_type)
        : Event(EventType::UNREGISTERED)
        , service_interface_type_(interface_type)
    {
    }
    boost::typeindex::type_index interface_type() const
    {
        return service_interface_type_;
    }

  private:
    boost::typeindex::type_index service_interface_type_;
};
}

class ServiceRegistry
{

    struct RegistrationInfo
    {
        RegistrationInfo()
            : raw_service(nullptr){};
        boost::typeindex::type_index service_interface;

        void *raw_service;
        std::unique_ptr<void, std::function<void(void *)>> unique_service;
    };
    using RegistrationInfoPtr = std::shared_ptr<RegistrationInfo>;

  public:
    using RegistrationHandle = std::weak_ptr<void>;

    template <typename ServiceInterface>
    RegistrationHandle register_service(std::unique_ptr<ServiceInterface> srv)
    {
        RegistrationInfoPtr registration;
        {
            std::lock_guard<std::mutex> lg(mutex_);

            auto type_index = boost::typeindex::type_id<ServiceInterface>();
            ASSERT_LOG(!services_.count(type_index),
                       "Already has a service registered for this interface: "
                           << type_index.pretty_name());
            registration                    = std::make_shared<RegistrationInfo>();
            registration->service_interface = type_index;
            registration->unique_service =
                std::unique_ptr<void, std::function<void(void *)>>(
                    srv.release(), [](void *service_instance) {
                        auto typed_service_ptr =
                            static_cast<ServiceInterface *>(service_instance);
                        ASSERT_LOG(service_instance && typed_service_ptr,
                                   "service_instance is null.");
                        delete typed_service_ptr;
                    });
            services_.insert(std::make_pair(type_index, registration));
        }
        signal_registration(registration);
        return registration;
    }

    template <typename ServiceInterface>
    RegistrationHandle register_service(ServiceInterface *srv)
    {
        RegistrationInfoPtr registration;
        {
            std::lock_guard<std::mutex> lg(mutex_);

            auto type_index = boost::typeindex::type_id<ServiceInterface>();
            ASSERT_LOG(!services_.count(type_index),
                       "Already has a service registered for this interface: "
                           << type_index.pretty_name());

            registration                    = std::make_shared<RegistrationInfo>();
            registration->service_interface = type_index;
            registration->raw_service       = srv;
            services_.insert(std::make_pair(type_index, registration));
        }
        signal_registration(registration);
        return registration;
    }

    bool unregister_service(RegistrationHandle h)
    {
        bool success = false;
        RegistrationInfoPtr registration_sptr;
        {
            std::lock_guard<std::mutex> lg(mutex_);

            std::shared_ptr<void> registration = h.lock();
            if (registration)
            {
                registration_sptr =
                    std::static_pointer_cast<RegistrationInfo>(registration);

                // We must check that the service is not currently in use. If that's
                // the
                // case we must prevent the unregistration of the service.
                // The reason for this if simple: It would make sense for the service
                // object to be deleted by its owner after a successful
                // unregister_service() call.
                // However, is someone else holds a reference to it, ... SEGV

                // SPTR to service: the registry itself, our registration
                // and registration_sptr objects.
                if (registration_sptr.use_count() > 3)
                {
                    // Someone else has a ref to this service.
                    return false;
                }

                // Sanity check
                ASSERT_LOG(
                    services_.count(registration_sptr->service_interface),
                    "Trying to unregister a service using an invalid handle.");
                services_.erase(registration_sptr->service_interface);
                success = true;
            }
        }
        if (success)
            signal_deregistration(registration_sptr);
        return success;
    }

    template <typename ServiceInterface>
    bool unregister_service()
    {
        bool success = false;
        RegistrationInfoPtr registration;
        {
            std::lock_guard<std::mutex> lg(mutex_);
            boost::typeindex::type_index idx =
                boost::typeindex::type_id<ServiceInterface>();
            auto itr = services_.find(idx);
            if (itr != services_.end())
            {
                registration = itr->second;

                // Count: One in the registry, and the registration object and the
                // iterator
                if (registration.use_count() > 3)
                {
                    // Someone is using the service. Cannot unregister.
                    return false;
                }
                services_.erase(idx);
                success = true;
            }
        }
        if (success)
            signal_deregistration(registration);
        return success;
    }

    template <typename ServiceInterface>
    std::shared_ptr<ServiceInterface> get_service() const
    {
        std::lock_guard<std::mutex> lg(mutex_);

        auto type_index = boost::typeindex::type_id<ServiceInterface>();
        auto itr        = services_.find(type_index);
        if (itr != services_.end())
        {
            auto &registration = itr->second;
            ServiceInterface *service_ptr;
            if (registration->raw_service)
                service_ptr =
                    static_cast<ServiceInterface *>(registration->raw_service);
            else
                service_ptr = static_cast<ServiceInterface *>(
                    registration->unique_service.get());
            return std::shared_ptr<ServiceInterface>(registration, service_ptr);
        }
        return nullptr;
    }

    template <typename ServiceInterface>
    long use_count() const
    {
        auto srv = get_service<ServiceInterface>();

        if (!srv)
        {
            return -1;
        }

        auto count = srv.use_count();
        ASSERT_LOG(count >= 2, "Hum, we are missing some shared_ptr...");

        // Don't count the pointer we just retrieved, nor the pointer
        // stored in the registry.
        return count - 2;
    }

    template <typename T>
    bs2::connection register_event_listener(T &&callable)
    {
        static_assert(std::is_convertible<T, EventListenerT>::value,
                      "Callable is not convertible to EventListenerT");
        return signal_.connect(callable);
    }

    using EventListenerT = std::function<void(const service_event::Event &)>;

  private:
    void signal_registration(const RegistrationInfoPtr &reg)
    {
        ASSERT_LOG(reg, "RegistrationInfoPtr is null");
        service_event::ServiceRegistered ev(reg->service_interface);
        signal_(ev);
    }

    void signal_deregistration(const RegistrationInfoPtr &reg)
    {
        ASSERT_LOG(reg, "RegistrationInfoPtr is null");
        service_event::ServiceUnregistered ev(reg->service_interface);
        signal_(ev);
    }

    mutable std::mutex mutex_;
    std::map<boost::typeindex::type_index, RegistrationInfoPtr> services_;
    bs2::signal<void(const service_event::Event &)> signal_;
};
}