soa/sigslot/signal.h

/* signal.h                                                      -*- C++ -*-
   Jeremy Barnes, 4 November 2010
   Copyright (c) 2010 Datacratic.  All rights reserved.

   A signal framework that allows for signals to be set up.
*/

#pragma once

#include "slot.h"
#include "jml/arch/rtti_utils.h"
#include <boost/function.hpp>
#include <unordered_map>
#include <boost/signals2.hpp>
#include "jml/utils/string_functions.h"

namespace Datacratic {


/*****************************************************************************/
/* SIGNAL INFO                                                               */
/*****************************************************************************/

struct SignalInfo {

    SignalInfo()
        : callbackType(0), objectType(0), inherited(false)
    {
    }

    Json::Value toJson() const;

    std::string eventName;  
    const std::type_info * callbackType;  
    const std::type_info * objectType;    
    bool inherited;         
};


/*****************************************************************************/
/* SIGNAL REGISTRY BASE                                                      */
/*****************************************************************************/

struct SignalRegistryBase {

    SignalRegistryBase();

    SignalRegistryBase(SignalRegistryBase & inheritFrom);

    ~SignalRegistryBase();

    size_t size() const { return signals.size(); }

    template<typename Class>
    SlotDisconnector on(const std::string & name,
                        Class * object,
                        const Slot & slot,
                        int priority = 0) const
    {
        return doOn(name, object, typeid(Class), slot, priority);
    }

    std::vector<std::string> names() const;

    SignalInfo info(const std::string & name) const;

    void inheritSignals(SignalRegistryBase & inheritFrom);

protected:
    typedef SlotDisconnector (* RegisterFn) (void * thisPtr,
                                             const std::type_info & thisType,
                                             const std::string & name,
                                             const Slot & slotToRegister,
                                             int priority,
                                             void * data);
    
    struct Info : public SignalInfo {
        Info()
            : registerFn(0), data(0)
        {
        }

        RegisterFn registerFn;  
        void * data;            
    };

    typedef std::unordered_map<std::string, Info> Signals;

    Signals signals;

    SlotDisconnector doOn(const std::string & name,
                          void * object,
                          const std::type_info & objectType,
                          const Slot & slot,
                          int priority) const;

    void add(const std::string & eventName,
             //const std::string & description, // TODO: would be nice...
             const std::type_info & callbackType,
             const std::type_info & objectType,
             RegisterFn registerFn, void * data = 0);

    typedef void (NewEvent) (const SignalRegistryBase &, const Info &);
    
    boost::signals2::signal<NewEvent> newEvent;

    std::vector<boost::signals2::connection> parentRegistrations;

    void addSignal(const Info & signal, bool inherited);
};


/*****************************************************************************/
/* SIGNAL REGISTRY                                                           */
/*****************************************************************************/

template<typename Class>
struct SignalRegistry : public SignalRegistryBase {

    SignalRegistry()
    {
    }

    template<typename Fn,
             SlotDisconnector (Class::* AddFn) (const std::string & name,
                                                const Slot & slot,
                                                int priority,
                                                void * data)>
    static SlotDisconnector doRegister(void * thisPtr,
                                       const std::type_info & thisType,
                                       const std::string & name,
                                       const Slot & slotToRegister,
                                       int priority,
                                       void * data)
    {
        Class * cl = (Class *)ML::is_convertible(thisType, typeid(Class),
                                                 thisPtr);
        if (!cl)
            throw ML::Exception("object of type " + ML::demangle(thisType)
                                + " at "
                                + ML::format("%p", thisPtr)
                                + " is not convertible to "
                                + ML::type_name<Class>()
                                + " trying to register for notification "
                                + name);
        return (cl ->* AddFn) (name, slotToRegister, priority);
    }

    template<typename Fn,
             SlotDisconnector (Class::* AddFn) (const boost::function<Fn> &,
                                                int priority)>
    struct Helper {
        static SlotDisconnector doRegister(void * thisPtr,
                                           const std::type_info & thisType,
                                           const std::string & name,
                                           const Slot & slotToRegister,
                                           int priority,
                                           void * data)
        {
            Class * cl = (Class *)ML::is_convertible(thisType, typeid(Class),
                                                     thisPtr);
            if (!cl)
                throw ML::Exception("object of type " + ML::demangle(thisType)
                                    + " at "
                                    + ML::format("%p", thisPtr)
                                    + " is not convertible to "
                                    + ML::type_name<Class>()
                                    + " trying to register for notification "
                                    + name);
            return (cl ->* AddFn) (slotToRegister.as<Fn>(), priority);
        }
    };

    template<typename Fn,
             SlotDisconnector (Class::* AddFn) (const Slot & slot,
                                                int priority)>
    void add(const std::string & name,
             void (Class::* addFn) (const Slot & slot, int priority))
    {
        SignalRegistryBase::
            add(name, typeid(Fn), typeid(Class), &doRegister<Fn, AddFn>, 0);
    }

    template<typename Fn,
             SlotDisconnector (Class::* AddFn) (const boost::function<Fn> & slot, int priority)>
    void add(const std::string & name)
    {
        RegisterFn fn = &Helper<Fn, AddFn>::doRegister;
        SignalRegistryBase::add(name, typeid(Fn), typeid(Class), fn, 0);
    }
};

struct DoRegisterSignals {
    template<typename Fn>
    DoRegisterSignals(Fn fn)
    {
        fn();
    }
};

} // namespace Datacratic