-
Notifications
You must be signed in to change notification settings - Fork 0
/
dynamic_proxy.cpp
82 lines (74 loc) · 2.19 KB
/
dynamic_proxy.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
//https://refactoring.guru/design-patterns/proxy/cpp/example
//https://refactoring.guru/design-patterns/proxy
#include <algorithm>
#include <iostream>
#include <list>
#include <string>
#include <memory>
class Subject
{
public:
Subject() { std::cout << "Subject constructor\n"; }
virtual ~Subject() { std::cout << "Subject destructor\n"; }
virtual void Request() = 0;
virtual void Request(int a) = 0;
};
using SubjectPtr = std::shared_ptr<Subject>;
class RealSubject : public Subject
{
public:
virtual void Request() final {
std::cout << "RealSubject: Handling request\n";
}
virtual void Request(int a) final {
std::cout << "RealSubject: Handling request : \t " << a << std::endl;
}
void Request2() {
std::cout << "RealSubject: Handling request\n";
}
};
using RealSubjectPtr = std::shared_ptr<RealSubject>;
template <typename T, typename F, typename ... args>
class Proxy
{
private:
std::shared_ptr<T> _realSubjectPtr;
F (T::*_fun)(args...);
private:
void Init() {
_realSubjectPtr.reset( new RealSubject);
}
bool CheckAcess() const {
std::cout << "Proxy: Checking access prior to firing a real request.\n";
return true;
}
void LogAccess() const {
std::cout << "Proxy: Logging the time of request.\n";
}
public:
Proxy(std::shared_ptr<T> realSubjectPtr, F (T::* f)(args...)) : _realSubjectPtr(realSubjectPtr), _fun(f) {}
~Proxy() {}
template <typename ... args>
void doSomeThing(args ... params) {
if (this->CheckAcess()) {
if (_realSubjectPtr.get() == nullptr)
Init();
(_realSubjectPtr.get()->*_fun)(std::forward<args>(params) ...);
LogAccess();
}
}
};
template <typename T, typename F, typename ... args>
std::shared_ptr<Proxy<T, F, args ... >> create(std::shared_ptr<T> realSubjectPtr, F (T::* f)(args ...)) {
return std::make_shared<Proxy<T, F, args ... >>(realSubjectPtr, f);
}
template <typename T, typename ... args>
std::shared_ptr<T> createPtr(args&& ... params) {
return std::make_shared<T>(std::forward<args>(params)...);
}
int main()
{
RealSubjectPtr realSubject = createPtr<RealSubject>();
auto proxyPtr = create(realSubject, &RealSubject::Request2);
proxyPtr->doSomeThing();
}