元编程应用-简单AOP

#include <iostream>
#include <type_traits>
#define HAS_MEMBER(member)\
template<typename T, typename... Args> \
struct has_member_##member { \
private:\
    template<typename U> \
    static auto Check(int) -> decltype(std::declval<U>().member(std::declval<Args>()...), std::true_type()); \
    template<typename U> \
    static std::false_type Check(...); \
public:\
    enum { value = std::is_same<decltype(Check<T>(0)), std::true_type>::value };   \
};\

HAS_MEMBER(Foo)
HAS_MEMBER(Before)
HAS_MEMBER(After)

template<typename Func, typename... Args>
struct Aspect {
    Aspect(const Aspect &) = delete;
    Aspect(Aspect &&) = delete;
    Aspect(Func&& f) : func_(std::forward<Func>(f)) {
    }
    template <typename T>
    typename std::enable_if<has_member_Before<T, Args...>::value && has_member_After<T, Args...>::value>::type Invoke(Args&&... args, T&& aspect) {
        aspect.Before(std::forward<Args>(args)...);
        func_(std::forward<Args>(args)...);
        aspect.After(std::forward<Args>(args)...);
    }
    template <typename T>
    typename std::enable_if<has_member_Before<T, Args...>::value && !has_member_After<T, Args...>::value>::type Invoke(Args&&... args, T&& aspect) {
        aspect.Before(std::forward<Args>(args)...);
        func_(std::forward<Args>(args)...);
    }
    template <typename T>
    typename std::enable_if<!has_member_Before<T, Args...>::value && has_member_After<T, Args...>::value>::type Invoke(Args&&... args, T&& aspect) {
        func_(std::forward<Args>(args)...);
        aspect.After(std::forward<Args>(args)...);
    }
    template <typename Head, typename... Tail>
    void Invoke(Args&&... args, Head&& headAspect, Tail&&... tailAspect) {
        headAspect.Before(std::forward<Args>(args)...);
        Invoke(std::forward<Args>(args)..., std::forward<Tail>(tailAspect)...);
        headAspect.After(std::forward<Args>(args)...);
    }
private:
    Func func_; 
};
template<typename T> using identity_t = T;
template<typename... AP, typename... Args, typename Func>
void Invoke(Func&&f, Args&&... args) {
    Aspect<Func, Args...> asp(std::forward<Func>(f));
    asp.Invoke(std::forward<Args>(args)..., identity_t<AP>()...);
}

struct TimeElapsedAspect {
    void Before(int i) {
        std::cout << "TimeElapsedAspect Before = " << i << std::endl;
    }
    void After(int i) {
        std::cout << "TimeElapsedAspect After = " << i << std::endl;
    }
};

struct LoggingAspect {
    void Before(int i) {
        std::cout << "LoggingAspect Before = " << i << std::endl;
    }
    void After(int i) {
        std::cout << "LoggingAspect After = " << i << std::endl;
    }
};

void foo(int a) {
    std::cout << "foo = " << a << std::endl;
}

int main() {
    Invoke<LoggingAspect, TimeElapsedAspect>(foo, 1); 
    std::cout << "------------------------------" << std::endl;
    Invoke<TimeElapsedAspect, LoggingAspect>(foo, 10);

    return 0;
}