mucbuc / dynamo (public) (License: GPLv3) (since 2020-06-28) (hash sha1)
Dispatch work to agents.
Clone URLs: https://rocketgit.com/user/mucbuc/dynamo ssh://rocketgit@ssh.rocketgit.com/user/mucbuc/dynamo git://git.rocketgit.com/user/mucbuc/dynamo
main master
List of commits:
Subject Hash Author Date (UTC)
Uni test (#2) 9b73df9337debfea1a000811645609bdd2d8a5ea Mark Busenitz 2018-06-25 10:46:04
license 8e6ee3e912b6273862fbecc34777ef8268ddd5dd mbusenitz 2017-11-21 04:38:04
doc hook (#1) 2d744d1ce1deb15ed20f1d5819de7e2d9230e2c7 Mark Busenitz 2017-03-25 20:27:28
package.json a4c059735b1201b5749b10f758fcfe3561d9ead6 mbusenitz 2017-03-21 04:20:38
Update README.md 2218a3a0dd2103de11dff6b15e670ad3874f4266 Mark Busenitz 2017-03-21 04:19:16
rm asserter.jsons 92c29fd451d0cfe128ea1ab18e82e379efdeb7af mbusenitz 2016-01-28 08:15:52
fix json b6ca8aebcfcde3acdc919e92004129d155755b8b mbusenitz 2015-10-22 04:37:08
jsonstuff 960242ccde70c18aa0fb1e72575fb84fde61040e mbusenitz 2015-10-22 04:34:42
json 4c6b6c5b3b00222e50562c8ace7ce67506a7ef98 mbusenitz 2015-10-16 04:25:06
fix build 82dcaff9abc9c68298522d47c7c175d855b6ffa2 mbusenitz 2015-09-26 10:39:35
rm test/plank 75bed7f551f1ca0f18ea34a3ab478ae6749bfad9 mbusenitz 2015-09-26 10:37:40
rm test/plank 7b1ad7a44ce2e3b2abb8024c14310099f5597a89 mbusenitz 2015-09-26 10:37:05
gitignore' 5bd4c2c8a9bc1befbec9de0d2487690e1a0b0fea mbusenitz 2015-09-26 10:36:39
cleanup be3e84988b097998550d5490fbbaec76670f5004 mbusenitz 2015-08-17 21:22:11
Squashed 'test/plank/' changes from 3d66229..4e4be36 81a33cac0e8e98f8435d975f81c6ae354a013455 mbusenitz 2015-08-17 21:21:33
m_.json dee0651fef2f9d675defffc3b9d34ccc6f213b64 mbusenitz 2015-08-01 04:50:41
Squashed 'test/plank/' content from commit 3d66229 67457e7330a167d3b1266b7e6cce413a274bc9b8 mbusenitz 2015-08-01 04:50:16
test passing on gcc fa1a492a81166b954501cd87d41f7eebc711b9ee Ubuntu 2015-07-25 05:29:39
ignore 5d88a4109278fbbe8b2b4155b0f51fbf002b8ed7 mbusenitz 2015-07-21 10:42:09
remove plank 72b9357832df405e498da540a30b1a19e245906b mbusenitz 2015-07-21 10:41:38
Commit 9b73df9337debfea1a000811645609bdd2d8a5ea - Uni test (#2)
* Uni test (#13)

* test doc hook

* test svg

* Uni test (#7)

* test doc hook

* test svg

* clang-format -i -style=WebKit *.cpp
Author: Mark Busenitz
Author date (UTC): 2018-06-25 10:46
Committer name: GitHub
Committer date (UTC): 2018-06-25 10:46
Parent(s): 8e6ee3e912b6273862fbecc34777ef8268ddd5dd
Signer:
Signing key: 4AEE18F83AFDEB23
Signing status: E
Tree: 64fb1f2a9d679043fe6500f1d5987682fccbbb37
File Lines added Lines deleted
src/agent.h 36 39
src/agent.hxx 85 87
src/batch.h 71 77
src/batch.hxx 165 168
src/dynamofwd.h 9 11
src/listener.h 15 20
src/listener.hxx 19 20
test/src/batch.h 33 33
test/src/main.cpp 6 6
File src/agent.h changed (mode: 100644) (index 8c68fdc..93b907b)
1 1 #ifndef AGENT_H__0OiXEmL5tPcgUywQFDMW6Gv1J8Hdzo #ifndef AGENT_H__0OiXEmL5tPcgUywQFDMW6Gv1J8Hdzo
2 2 #define AGENT_H__0OiXEmL5tPcgUywQFDMW6Gv1J8Hdzo #define AGENT_H__0OiXEmL5tPcgUywQFDMW6Gv1J8Hdzo
3 3
4 namespace om636
5 {
6 namespace control
7 {
8
9 template< typename T >
10 struct Agent
11 {
12 typedef T callback_type;
13 Agent( callback_type );
14
15 Agent(const Agent &) = delete;
16 Agent & operator=(const Agent &) = delete;
17
18 void invoke();
19
20 template<class V>
21 void invoke(V);
22
23 template<typename V, typename W>
24 void invoke(V, W);
25
26 void kill_invoke();
27
28 template<class V>
29 void kill_invoke(V);
30
31 template<typename V, typename W>
32 void kill_invoke(V, W);
33
34 void kill();
35 bool is_dead();
36
37 private:
38 callback_type m_callback;
39 };
40
41 } //control
42 } // om636
4 namespace om636 {
5 namespace control {
6
7 template <typename T>
8 struct Agent {
9 typedef T callback_type;
10 Agent(callback_type);
11
12 Agent(const Agent&) = delete;
13 Agent& operator=(const Agent&) = delete;
14
15 void invoke();
16
17 template <class V>
18 void invoke(V);
19
20 template <typename V, typename W>
21 void invoke(V, W);
22
23 void kill_invoke();
24
25 template <class V>
26 void kill_invoke(V);
27
28 template <typename V, typename W>
29 void kill_invoke(V, W);
30
31 void kill();
32 bool is_dead();
33
34 private:
35 callback_type m_callback;
36 };
37
38 } //control
39 } // om636
43 40
44 41 #include "agent.hxx" #include "agent.hxx"
45 42 #endif // AGENT_H__0OiXEmL5tPcgUywQFDMW6Gv1J8Hdzo #endif // AGENT_H__0OiXEmL5tPcgUywQFDMW6Gv1J8Hdzo
File src/agent.hxx changed (mode: 100644) (index fd182ed..5f3dde8)
1 namespace om636
2 {
3 namespace control
4 {
5
6 /////////////////////////////////////////////////////////////////////////////////////
7 // Agent
8 /////////////////////////////////////////////////////////////////////////////////////
9 template<typename T>
10 Agent<T>::Agent( callback_type callback )
11 : m_callback( callback )
12 {}
13
14 /////////////////////////////////////////////////////////////////////////////////////
15 template<typename T>
16 void Agent<T>::invoke()
17 {
18 ASSERT( !is_dead() );
19 m_callback();
20 }
21
22 /////////////////////////////////////////////////////////////////////////////////////
23 template<typename T>
24 template<typename V>
25 void Agent<T>::invoke( V v )
26 {
27 ASSERT( !is_dead() );
28 m_callback( v );
29 }
30
31 /////////////////////////////////////////////////////////////////////////////////////
32 template<typename T>
33 template<typename V, typename W>
34 void Agent<T>::invoke( V v, W w)
35 {
36 ASSERT( !is_dead() );
37 m_callback( v, w );
38 }
39
40 /////////////////////////////////////////////////////////////////////////////////////
41 template<typename T>
42 void Agent<T>::kill_invoke()
43 {
44 ASSERT( !is_dead() );
45 callback_type temp( m_callback );
46 kill();
47 temp();
48 }
49
50 /////////////////////////////////////////////////////////////////////////////////////
51 template<typename T>
52 template<typename V>
53 void Agent<T>::kill_invoke( V v )
54 {
55 ASSERT( !is_dead() );
56 callback_type temp( m_callback );
57 kill();
58 temp( v );
59 }
60
61 /////////////////////////////////////////////////////////////////////////////////////
62 template<typename T>
63 template<typename V, typename W>
64 void Agent<T>::kill_invoke( V v, W w)
65 {
66 ASSERT( !is_dead() );
67 callback_type temp( m_callback );
68 kill();
69 temp( v, w );
70
71 }
72
73 /////////////////////////////////////////////////////////////////////////////////////
74 template<typename T>
75 void Agent<T>::kill()
76 {
77 m_callback = callback_type();
78 }
79
80 /////////////////////////////////////////////////////////////////////////////////////
81 template<typename T>
82 bool Agent<T>::is_dead()
83 {
84 return !m_callback;
85 }
1 namespace om636 {
2 namespace control {
86 3
87 } //control
88 } // om636
4 /////////////////////////////////////////////////////////////////////////////////////
5 // Agent
6 /////////////////////////////////////////////////////////////////////////////////////
7 template <typename T>
8 Agent<T>::Agent(callback_type callback)
9 : m_callback(callback)
10 {
11 }
12
13 /////////////////////////////////////////////////////////////////////////////////////
14 template <typename T>
15 void Agent<T>::invoke()
16 {
17 ASSERT(!is_dead());
18 m_callback();
19 }
20
21 /////////////////////////////////////////////////////////////////////////////////////
22 template <typename T>
23 template <typename V>
24 void Agent<T>::invoke(V v)
25 {
26 ASSERT(!is_dead());
27 m_callback(v);
28 }
29
30 /////////////////////////////////////////////////////////////////////////////////////
31 template <typename T>
32 template <typename V, typename W>
33 void Agent<T>::invoke(V v, W w)
34 {
35 ASSERT(!is_dead());
36 m_callback(v, w);
37 }
38
39 /////////////////////////////////////////////////////////////////////////////////////
40 template <typename T>
41 void Agent<T>::kill_invoke()
42 {
43 ASSERT(!is_dead());
44 callback_type temp(m_callback);
45 kill();
46 temp();
47 }
48
49 /////////////////////////////////////////////////////////////////////////////////////
50 template <typename T>
51 template <typename V>
52 void Agent<T>::kill_invoke(V v)
53 {
54 ASSERT(!is_dead());
55 callback_type temp(m_callback);
56 kill();
57 temp(v);
58 }
59
60 /////////////////////////////////////////////////////////////////////////////////////
61 template <typename T>
62 template <typename V, typename W>
63 void Agent<T>::kill_invoke(V v, W w)
64 {
65 ASSERT(!is_dead());
66 callback_type temp(m_callback);
67 kill();
68 temp(v, w);
69 }
70
71 /////////////////////////////////////////////////////////////////////////////////////
72 template <typename T>
73 void Agent<T>::kill()
74 {
75 m_callback = callback_type();
76 }
77
78 /////////////////////////////////////////////////////////////////////////////////////
79 template <typename T>
80 bool Agent<T>::is_dead()
81 {
82 return !m_callback;
83 }
84
85 } //control
86 } // om636
File src/batch.h changed (mode: 100644) (index b32d08e..20f46af)
9 9 #include "agent.h" #include "agent.h"
10 10 #include "listener.h" #include "listener.h"
11 11
12 namespace om636
13 {
14 namespace control
15 {
16 template<typename T>
17 class Batch
18 {
19 public:
20
21 typedef T callback_type;
22 typedef Agent< callback_type > agent_type;
23 typedef std::shared_ptr< agent_type > pointer_type;
24 typedef Listener< pointer_type > listener_type;
25 typedef std::multiset< pointer_type > batch_type;
26
27 Batch() = default;
28 virtual ~Batch() = default;
29 Batch(const Batch &) = delete;
30 Batch & operator=(const Batch &) = delete;
31
32 listener_type hook(callback_type);
33 void unhook();
34 void traverse();
35
36 template<class V>
37 void traverse( V );
38
39 template<typename V, typename W>
40 void traverse( V, W );
41
42 void traverse_destructive();
43
44 template<class V>
45 void traverse_destructive( V );
46
47 template<typename V, typename W>
48 void traverse_destructive( V, W );
49
50 batch_type & elements();
51 const batch_type & elements() const;
52
53 void merge_added_elements();
54
55 private:
56
57 batch_type m_elements;
58 batch_type m_elements_add;
59 };
60
61 namespace utils
62 {
63
64 template<typename T>
65 void process_and_kill( T & );
66
67 template<typename T, typename V>
68 void process_and_kill( T &, V );
69
70 template<typename T, typename V, typename W>
71 void process_and_kill( T &, V, W );
72
73 template<typename T>
74 void process( T & );
75
76 template<typename T, typename V>
77 void process( T &, V );
78
79 template<typename T, typename V, typename W>
80 void process( T &, V, W );
81
82 template<typename T>
83 void kill_all(T &);
84 }
85
86 } //control
87 } // om636
12 namespace om636 {
13 namespace control {
14 template <typename T>
15 class Batch {
16 public:
17 typedef T callback_type;
18 typedef Agent<callback_type> agent_type;
19 typedef std::shared_ptr<agent_type> pointer_type;
20 typedef Listener<pointer_type> listener_type;
21 typedef std::multiset<pointer_type> batch_type;
22
23 Batch() = default;
24 virtual ~Batch() = default;
25 Batch(const Batch&) = delete;
26 Batch& operator=(const Batch&) = delete;
27
28 listener_type hook(callback_type);
29 void unhook();
30 void traverse();
31
32 template <class V>
33 void traverse(V);
34
35 template <typename V, typename W>
36 void traverse(V, W);
37
38 void traverse_destructive();
39
40 template <class V>
41 void traverse_destructive(V);
42
43 template <typename V, typename W>
44 void traverse_destructive(V, W);
45
46 batch_type& elements();
47 const batch_type& elements() const;
48
49 void merge_added_elements();
50
51 private:
52 batch_type m_elements;
53 batch_type m_elements_add;
54 };
55
56 namespace utils {
57
58 template <typename T>
59 void process_and_kill(T&);
60
61 template <typename T, typename V>
62 void process_and_kill(T&, V);
63
64 template <typename T, typename V, typename W>
65 void process_and_kill(T&, V, W);
66
67 template <typename T>
68 void process(T&);
69
70 template <typename T, typename V>
71 void process(T&, V);
72
73 template <typename T, typename V, typename W>
74 void process(T&, V, W);
75
76 template <typename T>
77 void kill_all(T&);
78 }
79
80 } //control
81 } // om636
88 82
89 83 #include "batch.hxx" #include "batch.hxx"
90 84
91 #endif
85 #endif
File src/batch.hxx changed (mode: 100644) (index 6f1e001..b459641)
1 namespace om636
2 {
3 namespace control
4 {
5 /////////////////////////////////////////////////////////////////////////////////////
6 template<typename T>
7 auto Batch<T>::hook( callback_type c ) -> listener_type
8 {
9 pointer_type agent( new agent_type( c ) );
10 m_elements_add.insert( agent );
11 return listener_type( agent );
12 }
13
14 /////////////////////////////////////////////////////////////////////////////////////
15 template<typename T>
16 void Batch<T>::unhook()
17 {
18 utils::kill_all( elements() );
19 utils::kill_all( m_elements_add );
20 }
21
22 /////////////////////////////////////////////////////////////////////////////////////
23 template<typename T>
24 void Batch<T>::traverse()
25 {
26 merge_added_elements();
27
28 utils::process( elements() );
29 }
30
31 /////////////////////////////////////////////////////////////////////////////////////
32 template<typename T>
33 template<class V>
34 void Batch<T>::traverse(V arg)
35 {
36 merge_added_elements();
37
38 utils::process( elements(), arg );
39 }
40
41 /////////////////////////////////////////////////////////////////////////////////////
42 template<typename T>
43 template<typename V, typename W>
44 void Batch<T>::traverse(V first_arg, W second_arg )
45 {
46 merge_added_elements();
47
48 utils::process( elements(), first_arg, second_arg );
49 }
50
1 namespace om636 {
2 namespace control {
3 /////////////////////////////////////////////////////////////////////////////////////
4 template <typename T>
5 auto Batch<T>::hook(callback_type c) -> listener_type
6 {
7 pointer_type agent(new agent_type(c));
8 m_elements_add.insert(agent);
9 return listener_type(agent);
10 }
11
12 /////////////////////////////////////////////////////////////////////////////////////
13 template <typename T>
14 void Batch<T>::unhook()
15 {
16 utils::kill_all(elements());
17 utils::kill_all(m_elements_add);
18 }
19
20 /////////////////////////////////////////////////////////////////////////////////////
21 template <typename T>
22 void Batch<T>::traverse()
23 {
24 merge_added_elements();
25
26 utils::process(elements());
27 }
28
29 /////////////////////////////////////////////////////////////////////////////////////
30 template <typename T>
31 template <class V>
32 void Batch<T>::traverse(V arg)
33 {
34 merge_added_elements();
35
36 utils::process(elements(), arg);
37 }
38
39 /////////////////////////////////////////////////////////////////////////////////////
40 template <typename T>
41 template <typename V, typename W>
42 void Batch<T>::traverse(V first_arg, W second_arg)
43 {
44 merge_added_elements();
45
46 utils::process(elements(), first_arg, second_arg);
47 }
48
49 /////////////////////////////////////////////////////////////////////////////////////
50 template <typename T>
51 void Batch<T>::traverse_destructive()
52 {
53 merge_added_elements();
54
55 utils::process_and_kill(elements());
56 }
57
58 /////////////////////////////////////////////////////////////////////////////////////
59 template <typename T>
60 template <class V>
61 void Batch<T>::traverse_destructive(V arg)
62 {
63 merge_added_elements();
64
65 utils::process_and_kill(elements(), arg);
66 }
67
68 /////////////////////////////////////////////////////////////////////////////////////
69 template <typename T>
70 template <typename V, typename W>
71 void Batch<T>::traverse_destructive(V first_arg, W second_arg)
72 {
73 merge_added_elements();
74
75 utils::process_and_kill(elements(), first_arg, second_arg);
76 }
77
78 /////////////////////////////////////////////////////////////////////////////////////
79 template <typename T>
80 auto Batch<T>::elements() -> batch_type&
81 {
82 return m_elements;
83 }
84
85 /////////////////////////////////////////////////////////////////////////////////////
86 template <typename T>
87 auto Batch<T>::elements() const -> const batch_type&
88 {
89 return m_elements;
90 }
91
92 /////////////////////////////////////////////////////////////////////////////////////
93 template <typename T>
94 void Batch<T>::merge_added_elements()
95 {
96 elements().insert(m_elements_add.begin(), m_elements_add.end());
97 m_elements_add.clear();
98 }
99
100 namespace utils {
51 101 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
52 template<typename T>
53 void Batch<T>::traverse_destructive()
102 template <typename T>
103 void process(T& elements)
54 104 { {
55 merge_added_elements();
56
57 utils::process_and_kill( elements() );
105 T copy(elements);
106 for_each(copy.begin(), copy.end(), [&](typename T::value_type p) {
107 if (!p->is_dead())
108 p->invoke();
109 else
110 elements.erase(p);
111 });
58 112 } }
59
113
60 114 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
61 template<typename T>
62 template<class V>
63 void Batch<T>::traverse_destructive(V arg)
115 template <typename T, typename V>
116 void process(T& elements, V v)
64 117 { {
65 merge_added_elements();
66
67 utils::process_and_kill( elements(), arg );
118 T copy(elements);
119 for_each(copy.begin(), copy.end(), [&](typename T::value_type p) {
120 if (!p->is_dead())
121 p->invoke(v);
122 else
123 elements.erase(p);
124 });
68 125 } }
69
126
70 127 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
71 template<typename T>
72 template<typename V, typename W>
73 void Batch<T>::traverse_destructive(V first_arg, W second_arg )
128 template <typename T, typename V, typename W>
129 void process(T& elements, V v, W w)
74 130 { {
75 merge_added_elements();
76
77 utils::process_and_kill( elements(), first_arg, second_arg );
131 T copy(elements);
132 for_each(copy.begin(), copy.end(), [&](typename T::value_type p) {
133 if (!p->is_dead())
134 p->invoke(v, w);
135 else
136 elements.erase(p);
137 });
78 138 } }
79 139
80 140 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
81 template<typename T>
82 auto Batch<T>::elements() -> batch_type &
141 template <typename T>
142 void process_and_kill(T& elements)
83 143 { {
84 return m_elements;
144 T copy(elements);
145 for_each(copy.begin(), copy.end(), [](typename T::value_type p) {
146 if (!p->is_dead())
147 p->kill_invoke();
148 });
149 elements.clear();
85 150 } }
86 151
87 152 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
88 template<typename T>
89 auto Batch<T>::elements() const -> const batch_type &
153 template <typename T, typename V>
154 void process_and_kill(T& elements, V v)
90 155 { {
91 return m_elements;
156 T copy(elements);
157 for_each(copy.begin(), copy.end(), [&](typename T::value_type p) {
158 if (!p->is_dead())
159 p->kill_invoke(v);
160 });
161 elements.clear();
92 162 } }
93
163
94 164 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
95 template<typename T>
96 void Batch<T>::merge_added_elements()
165 template <typename T, typename V, typename W>
166 void process_and_kill(T& elements, V v, W w)
97 167 { {
98 elements().insert(m_elements_add.begin(), m_elements_add.end() );
99 m_elements_add.clear();
168 T copy(elements);
169 for_each(copy.begin(), copy.end(), [&](typename T::value_type p) {
170 if (!p->is_dead())
171 p->kill_invoke(v, w);
172 });
173 elements.clear();
100 174 } }
101 175
102 namespace utils
176 /////////////////////////////////////////////////////////////////////////////////////
177 template <typename T>
178 void kill_all(T& elements)
103 179 { {
104 /////////////////////////////////////////////////////////////////////////////////////
105 template<typename T>
106 void process( T & elements )
107 {
108 T copy(elements);
109 for_each( copy.begin(), copy.end(), [&](typename T::value_type p) {
110 if (!p->is_dead())
111 p->invoke();
112 else
113 elements.erase(p);
114 } );
115 }
116
117 /////////////////////////////////////////////////////////////////////////////////////
118 template<typename T, typename V>
119 void process( T & elements, V v )
120 {
121 T copy(elements);
122 for_each( copy.begin(), copy.end(), [&](typename T::value_type p) {
123 if (!p->is_dead())
124 p->invoke(v);
125 else
126 elements.erase(p);
127 } );
128 }
129
130 /////////////////////////////////////////////////////////////////////////////////////
131 template<typename T, typename V, typename W>
132 void process( T & elements, V v, W w )
133 {
134 T copy(elements);
135 for_each( copy.begin(), copy.end(), [&](typename T::value_type p) {
136 if (!p->is_dead())
137 p->invoke(v, w);
138 else
139 elements.erase(p);
140 } );
141 }
142
143 /////////////////////////////////////////////////////////////////////////////////////
144 template<typename T>
145 void process_and_kill( T & elements )
146 {
147 T copy(elements);
148 for_each( copy.begin(), copy.end(), [](typename T::value_type p) {
149 if (!p->is_dead())
150 p->kill_invoke();
151 } );
152 elements.clear();
153 }
154
155 /////////////////////////////////////////////////////////////////////////////////////
156 template<typename T, typename V>
157 void process_and_kill( T & elements, V v )
158 {
159 T copy(elements);
160 for_each( copy.begin(), copy.end(), [&](typename T::value_type p) {
161 if (!p->is_dead())
162 p->kill_invoke(v);
163 } );
164 elements.clear();
165 }
166
167 /////////////////////////////////////////////////////////////////////////////////////
168 template<typename T, typename V, typename W>
169 void process_and_kill( T & elements, V v, W w )
170 {
171 T copy(elements);
172 for_each( copy.begin(), copy.end(), [&](typename T::value_type p) {
173 if (!p->is_dead())
174 p->kill_invoke(v, w);
175 } );
176 elements.clear();
177 }
178
179 /////////////////////////////////////////////////////////////////////////////////////
180 template<typename T>
181 void kill_all(T & elements)
182 {
183 for_each( elements.begin(), elements.end(), [](typename T::value_type p) {
184 p->kill();
185 } );
186 elements.clear();
187 }
188 } // utils
189 } // control
190 } // om636
180 for_each(elements.begin(), elements.end(), [](typename T::value_type p) {
181 p->kill();
182 });
183 elements.clear();
184 }
185 } // utils
186 } // control
187 } // om636
File src/dynamofwd.h changed (mode: 100644) (index 7d91af0..6666fd9)
1 namespace om636
2 {
3 namespace control
4 {
5 template<typename>
6 struct Agent;
1 namespace om636 {
2 namespace control {
3 template <typename>
4 struct Agent;
7 5
8 template<typename>
9 struct Listener;
6 template <typename>
7 struct Listener;
10 8
11 template<typename, typename>
12 struct Batch;
13 }
9 template <typename, typename>
10 struct Batch;
11 }
14 12 } }
File src/listener.h changed (mode: 100644) (index 88d5b05..5b77f03)
1 1 #ifndef LISTENER_H__UCaPZDc8YNktrFzRqufGj4OJng9bym #ifndef LISTENER_H__UCaPZDc8YNktrFzRqufGj4OJng9bym
2 2 #define LISTENER_H__UCaPZDc8YNktrFzRqufGj4OJng9bym #define LISTENER_H__UCaPZDc8YNktrFzRqufGj4OJng9bym
3 3
4 namespace om636 {
5 namespace control {
4 6
5 namespace om636
6 {
7 namespace control
8 {
7 template <typename T>
8 struct Listener {
9 typedef T owner_type;
10 Listener(owner_type);
11 ~Listener();
12 Listener(const Listener&) = default;
13 Listener& operator=(const Listener&) = default;
14 Listener() = default;
9 15
10 template< typename T >
11 struct Listener
12 {
13 typedef T owner_type;
14 Listener( owner_type );
15 ~Listener();
16 Listener( const Listener & ) = default;
17 Listener & operator=(const Listener &) = default;
18 Listener() = default;
19
20 private:
21
22 owner_type m_agent;
23 };
16 private:
17 owner_type m_agent;
18 };
24 19
25 } //control
26 } // om636
20 } //control
21 } // om636
27 22
28 23 #include "listener.hxx" #include "listener.hxx"
29 24 #endif // LISTENER_H__UCaPZDc8YNktrFzRqufGj4OJng9bym #endif // LISTENER_H__UCaPZDc8YNktrFzRqufGj4OJng9bym
File src/listener.hxx changed (mode: 100644) (index e6d20b0..86d7a80)
1 namespace om636
2 {
3 namespace control
4 {
5 /////////////////////////////////////////////////////////////////////////////////////
6 template<typename T>
7 Listener<T>::Listener( owner_type agent )
8 : m_agent( agent )
9 {}
10
11 /////////////////////////////////////////////////////////////////////////////////////
12 template<typename T>
13 Listener<T>::~Listener()
14 {
15 // this is the only listener, the other owner is the batch
16 if (m_agent.use_count() == 2)
17 m_agent->kill();
18 }
19 } //control
20 } // om636
1 namespace om636 {
2 namespace control {
3 /////////////////////////////////////////////////////////////////////////////////////
4 template <typename T>
5 Listener<T>::Listener(owner_type agent)
6 : m_agent(agent)
7 {
8 }
9
10 /////////////////////////////////////////////////////////////////////////////////////
11 template <typename T>
12 Listener<T>::~Listener()
13 {
14 // this is the only listener, the other owner is the batch
15 if (m_agent.use_count() == 2)
16 m_agent->kill();
17 }
18 } //control
19 } // om636
File test/src/batch.h changed (mode: 100644) (index eb652de..d597c61)
... ... typedef control::Batch<callback_type> batch_type;
7 7 void check_traverse_with_arg() void check_traverse_with_arg()
8 8 { {
9 9 typedef function<void(int)> callback_type; typedef function<void(int)> callback_type;
10 typedef control::Batch<callback_type> batch_type;
11
10 typedef control::Batch<callback_type> batch_type;
11
12 12 unsigned test_passed(0); unsigned test_passed(0);
13 13 batch_type batch; batch_type batch;
14 14
15 auto p( batch.hook( [&](int i){
16 ASSERT( i == 99 );
15 auto p(batch.hook([&](int i) {
16 ASSERT(i == 99);
17 17 ++test_passed; ++test_passed;
18 } ) );
18 }));
19
20 batch.traverse(99);
19 21
20 batch.traverse( 99 );
21
22 ASSERT( test_passed == 1 );
22 ASSERT(test_passed == 1);
23 23 FOOTER; FOOTER;
24 24 } }
25 25
26 26 void check_traverse_with_args() void check_traverse_with_args()
27 27 { {
28 28 typedef function<void(int, int)> callback_type; typedef function<void(int, int)> callback_type;
29 typedef control::Batch<callback_type> batch_type;
30
29 typedef control::Batch<callback_type> batch_type;
30
31 31 unsigned test_passed(0); unsigned test_passed(0);
32 32 batch_type batch; batch_type batch;
33 33
34 auto p( batch.hook( [&](int i, int j){
35 ASSERT( i == 99 );
36 ASSERT( j == 3 );
34 auto p(batch.hook([&](int i, int j) {
35 ASSERT(i == 99);
36 ASSERT(j == 3);
37 37 ++test_passed; ++test_passed;
38 } ) );
38 }));
39 39
40 batch.traverse( 99, 3 );
41
42 ASSERT( test_passed == 1 );
40 batch.traverse(99, 3);
41
42 ASSERT(test_passed == 1);
43 43 FOOTER; FOOTER;
44 44 } }
45 45
46 46 void check_traverse_while_traverse() void check_traverse_while_traverse()
47 47 { {
48 batch_type batch;
49 unsigned passed(0);
50
51 auto p( batch.hook( [&](){
48 batch_type batch;
49 unsigned passed(0);
50
51 auto p(batch.hook([&]() {
52 52 ++passed; ++passed;
53 53 batch.traverse(); batch.traverse();
54 } ) );
55
54 }));
55
56 56 batch.traverse(); batch.traverse();
57 57
58 ASSERT( passed == 1 );
58 ASSERT(passed == 1);
59 59 FOOTER; FOOTER;
60 60 } }
61 61
62 62 void check_traverse() void check_traverse()
63 63 { {
64 batch_type batch;
65 unsigned passed(0);
64 batch_type batch;
65 unsigned passed(0);
66 66
67 auto temp(batch.hook( [&](){
68 ++passed;
69 } ) );
67 auto temp(batch.hook([&]() {
68 ++passed;
69 }));
70 70
71 batch.traverse();
72 batch.traverse();
71 batch.traverse();
72 batch.traverse();
73 73
74 ASSERT( passed == 2 );
75 FOOTER;
74 ASSERT(passed == 2);
75 FOOTER;
76 76 } }
File test/src/main.cpp changed (mode: 100644) (index a0c36d6..6e4b832)
1 #include <iostream>
2 1 #include <functional> #include <functional>
2 #include <iostream>
3 3
4 4 #include <tmp/src/test.h> #include <tmp/src/test.h>
5 5
 
7 7
8 8 #include "batch.h" #include "batch.h"
9 9
10 int main(int argc, const char * argv[])
10 int main(int argc, const char* argv[])
11 11 { {
12 12 check_traverse(); check_traverse();
13 //check_traverse_while_traverse();
14 check_traverse_with_arg();
15 check_traverse_with_args();
13 //check_traverse_while_traverse();
14 check_traverse_with_arg();
15 check_traverse_with_args();
16 16
17 return 0;
17 return 0;
18 18 } }
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/mucbuc/dynamo

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/mucbuc/dynamo

Clone this repository using git:
git clone git://git.rocketgit.com/user/mucbuc/dynamo

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main