managers.hpp

Go to the documentation of this file.

/*****************************************************************************
** Ifdefs
*****************************************************************************/

#ifndef ECL_SIGSLOTS_LITE_MANAGERS_HPP_
#define ECL_SIGSLOTS_LITE_MANAGERS_HPP_

/*****************************************************************************
** Includes
*****************************************************************************/

#include "slot.hpp"

/*****************************************************************************
** Namespaces
*****************************************************************************/

namespace ecl {
namespace lite {

/*****************************************************************************
** Forward Declarations
*****************************************************************************/

template <typename Data, unsigned int Capacity> class Signal;

/*****************************************************************************
** Managers
*****************************************************************************/

namespace sigslots {
template <typename Data, typename FunctionClass>
class MemberSlotsBase {
public:
        virtual unsigned int stored() const { return 0; }
        virtual unsigned int capacity() const { return 0; }
        virtual sigslots::MemberSlot<Data,FunctionClass>* addSlot(void (FunctionClass::*func)(Data), FunctionClass &instance) = 0;
};

template <typename FunctionClass>
class MemberSlotsBase<void,FunctionClass> {
public:
        virtual unsigned int stored() const { return 0; }
        virtual unsigned int capacity() const { return 0; }
        virtual sigslots::MemberSlot<void,FunctionClass>* addSlot(void (FunctionClass::*func)(), FunctionClass &instance) = 0;
};

} // namespace sigslots

/******************************************
** Member Manager
*******************************************/
template <typename Data, typename FunctionClass, unsigned int Capacity = 1>
class MemberSlots : public sigslots::MemberSlotsBase<Data,FunctionClass> {
public:
        /*********************
        ** Friends
        **********************/
        // allow connect to use addSlot
        template <typename Data_, unsigned int Capacity_, typename FunctionClass_>
        friend sigslots::Error connect(Signal<Data_,Capacity_> &signal, void(FunctionClass_::*f)(Data_), FunctionClass_ &o);

        // needs access to stored()
        template <typename Data_, typename FunctionClass_>
        friend unsigned int member_slots_stored(const FunctionClass_ &object);

        // needs access to capacity()
        template <typename Data_, typename FunctionClass_>
        friend unsigned int member_slots_capacity(const FunctionClass_ &object);


protected:
        MemberSlots() : size(0) {};

private:
        unsigned int stored() const { return size; }
        unsigned int capacity() const { return Capacity; }

        sigslots::MemberSlot<Data,FunctionClass>* addSlot(void (FunctionClass::*func)(Data), FunctionClass &instance) {
                for ( unsigned int i = 0; i < size; ++i ) {
                        if ( func == slots[i].member_function ) {
                                return &(slots[i]);
                        }
                }
                if ( size < Capacity ) {
                        slots[size] = sigslots::MemberSlot<Data,FunctionClass>(func,instance);
                        ++size;
                        return &(slots[size-1]);
                } else {
                        return NULL;
                }
        }

        unsigned int size;
        sigslots::MemberSlot<Data,FunctionClass> slots[Capacity];
};

/******************************************
** Global Manager
*******************************************/

template <typename Data, typename Dummy = int>
class GlobalSlots {
public:
        static const unsigned int capacity;
        /*********************
        ** Friends
        **********************/
        // needs access to addSlot()
        template <typename Data_, unsigned int Capacity_>
        friend sigslots::Error connect(Signal<Data_, Capacity_> &signal, void (*function)(Data_));

        // needs access to stored()
        template <typename Data_>
        friend unsigned int global_slots_stored();

private:
        static unsigned int stored(const bool increment = false) {
                static unsigned int stored_slots = 0;
                if ( increment ) { ++stored_slots; }
                return stored_slots;
        }
        static sigslots::GlobalSlot<Data>* addSlot(void (*func)(Data)) {
                unsigned int size = stored();
                static sigslots::GlobalSlot<Data> slots[capacity];
                for ( unsigned int i = 0; i < size; ++i ) {
                        if ( func == slots[i].global_function ) {
                                return &(slots[i]);
                        }
                }
                if ( size < capacity ) {
                        slots[size] = sigslots::GlobalSlot<Data>(func);
                        bool inc = true;
                        stored(inc); // increment the number of stored slots variable
                        return &(slots[size]);
                } else {
                        return NULL;
                }
        }
};

/*****************************************************************************
** Specialisations
*****************************************************************************/
template <typename FunctionClass, unsigned int Capacity>
class MemberSlots<void, FunctionClass, Capacity> : public sigslots::MemberSlotsBase<void,FunctionClass> {
public:
        /*********************
        ** Friends
        **********************/
        // allow connect to use addSlot
        template <unsigned int Capacity_, typename FunctionClass_>
        friend sigslots::Error connect(Signal<void,Capacity_> &signal, void(FunctionClass_::*f)(void), FunctionClass_ &o);
        // needs access to stored()
        template <typename Data_, typename FunctionClass_>
        friend unsigned int member_slots_stored(const FunctionClass_ &object);

        // needs access to capacity()
        template <typename Data_, typename FunctionClass_>
        friend unsigned int member_slots_capacity(const FunctionClass_ &object);

protected:
        MemberSlots() : size(0) {};

private:
        unsigned int stored() const { return size; }

        unsigned int capacity() const { return Capacity; }

        sigslots::MemberSlot<void,FunctionClass>* addSlot(void (FunctionClass::*func)(void), FunctionClass &instance) {
                for ( unsigned int i = 0; i < size; ++i ) {
                        if ( func == slots[i].member_function ) {
                                return &(slots[i]);
                        }
                }
                if ( size < Capacity ) {
                        slots[size] = sigslots::MemberSlot<void,FunctionClass>(func,instance);
                        ++size;
                        return &(slots[size-1]);
                } else {
                        return NULL;
                }
        }

        unsigned int size;
        sigslots::MemberSlot<void,FunctionClass> slots[Capacity];
};

template <typename Dummy>
class GlobalSlots<void, Dummy> {
public:
        static const unsigned int capacity; 
        /*********************
        ** Friends
        **********************/
        // needs access to addSlot()
        template <unsigned int Capacity_>
        friend sigslots::Error connect(Signal<void,Capacity_> &signal, void (*function)(void));

        // needs access to stored()
        template <typename Data> friend unsigned int global_slots_stored();

private:
        static unsigned int stored(const bool increment = false) {
                static unsigned int stored_slots = 0;
                if ( increment ) { ++stored_slots; }
                return stored_slots;
        }

        static sigslots::GlobalSlot<void>* addSlot(void (*func)(void)) {
                unsigned int size = stored();
                static sigslots::GlobalSlot<void> slots[capacity];
                for ( unsigned int i = 0; i < size; ++i ) {
                        if ( func == slots[i].global_function ) {
                                return &(slots[i]);
                        }
                }
                if ( size < capacity ) {
                        slots[size] = sigslots::GlobalSlot<void>(func);
                        bool inc = true;
                        stored(inc); // increment the number of stored slots variable
                        return &(slots[size]);
                } else {
                        return NULL;
                }
        }
};


} // namespace lite
} // namespace ecl

#endif /* ECL_SIGSLOTS_LITE_MANAGERS_HPP_ */