template<typename S> struct CActiveDelegate
    {
        fastdelegate::FastDelegate<S>    Function;
        std::function<S>        Lambda;
        int                Listen;

        CActiveDelegate()
        {
        }
    };

    template<class X, class Y, typename...A> auto CreateActiveDelegate(Y* x, void (X::*func)(A...), int l)
    { 
        CActiveDelegate<void(A...)> d;
        d.Function = fastdelegate::FastDelegate<void(A...)>(x, func);
        d.Listen = l;
        return d;
    }


    template<class L> auto CreateLambdaDelegate(L la, int l)
    { 
        CActiveDelegate<typename fn::traits<L>::signature> d;
        d.Lambda = la;
        d.Listen = l;
        return d;
    }

    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
    #define LambdaSubscriber(la, l)            CreateLambdaDelegate(la, l)

    template<class ...A> class CActiveEvent
    {
        public:
            void operator += (CActiveDelegate<void(A...)> & d)
            {
                Subscribers.push_back(d);
            }

        protected:
            std::list<CActiveDelegate<void(A...)>>    Subscribers;
    };


    class A
    {
        void AAA(std::string &)
        {
            CActiveEvent<std::string &> aaa;

            aaa += FunctionSubscriber(AAA, 1);
            aaa += LambdaSubscriber([](std::string &){}, 2);

        }
    };