mucbuc / ohm (public) (License: GPLv3) (since 2020-06-28) (hash sha1)
No description available
Clone URLs: https://rocketgit.com/user/mucbuc/ohm ssh://rocketgit@ssh.rocketgit.com/user/mucbuc/ohm git://git.rocketgit.com/user/mucbuc/ohm
main master
List of commits:
Subject Hash Author Date (UTC)
format e59b4ae5d0286ba6766e66427996f8ccab4eff0e Ubuntu 2019-12-18 07:38:21
redo interface 3dd5822c6288ad004d1ec45e37a6f63d361aff39 Ubuntu 2019-12-18 07:38:11
temp test 54800db7dbd02d7070f5018abd27bea261bd9097 Ubuntu 2019-12-18 07:07:07
cleanup test 58f12d14f6db17e0916b115f470f87393e1ebce6 Ubuntu 2019-12-15 14:52:15
fix build error 51fcd8e612a8e89cf6ef2c94cfb82b664b532313 mucbuc 2019-11-29 06:49:34
moved impl back e536719eb2c090e49e1f389deed19dbdcd582275 mucbuc 2019-11-27 15:17:35
emitter_impl 4d41cb0eb6ee37a66b9c8d3b02824ec2020bca31 mucbuc 2019-11-26 10:58:35
using template parameter packs b01b5f9568215ccfd5c7c30cfb68ccc8a3c720da mucbuc 2019-11-14 14:21:50
cleanup 0403bb7332d11797467282d58735cefb518e8407 mucbuc 2019-11-12 05:13:03
rm emitter 55ae1aa2ce377d75e47d18a2ed29b44b7e24f93f mucbuc 2019-11-12 04:49:21
once while emit recursive 172a4d72599206575d18b2055e5a0231646d9274 mucbuc 2019-11-12 04:44:22
once_wile_emit 785a96521c22785401b9408a54a4ffb5c1541fa1 mucbuc 2019-11-12 04:37:40
on_while_emit 40ce61bbb69d5557944c3055d7fca492acf86e70 mucbuc 2019-11-11 15:21:30
modify while traverse ed70186f19dea7c92a9b98c0df7aec4973a37b98 mucbuc 2019-11-11 15:10:58
on test b8fc778d7056fb108fbdd7318f294e2b340faeeb mucbuc 2019-11-11 15:01:22
emit with args a40831a0902f0dfa35d8f5e314b1e5b21955eae7 mucbuc 2019-11-11 14:40:46
emit with arg 2cfab1f1668896ac6d58e868b8ee6d41a79dc447 mucbuc 2019-11-11 02:45:45
check dispatch logic 5b40033514e610292c25336b821829675c8f7edd mucbuc 2019-11-11 02:35:18
another test 718946ff7621bab0d8242e19ab423626c41a0b97 mucbuc 2019-11-11 02:20:42
emit once d3d244834caec7f581b254957c22b8f1c2af5321 mucbuc 2019-11-11 00:31:05
Commit e59b4ae5d0286ba6766e66427996f8ccab4eff0e - format
Author: Ubuntu
Author date (UTC): 2019-12-18 07:38
Committer name: Ubuntu
Committer date (UTC): 2019-12-18 07:38
Parent(s): 3dd5822c6288ad004d1ec45e37a6f63d361aff39
Signer:
Signing key:
Signing status: N
Tree: 1e025640bdf93ac0578af4c2c6388e30cd98b54f
File Lines added Lines deleted
src/emitter_impl.h 6 6
src/emitter_impl.hxx 14 14
src/interface.h 11 12
src/quemitter.h 4 4
src/quemitter_impl.h 12 14
src/quemitter_impl.hxx 19 20
File src/emitter_impl.h changed (mode: 100644) (index fbd4ac5..ae5d6f7)
5 5 #include <memory> #include <memory>
6 6 #include <set> #include <set>
7 7
8 #include "interface.h"
8 #include "interface.h"
9 9
10 10 namespace om636 { namespace om636 {
11 11 namespace control { namespace control {
12 template <typename T, typename ... U>
13 class EmitterImpl : Emitter<T, U ...>
14 {
12 template <typename T, typename... U>
13 class EmitterImpl : Emitter<T, U...> {
15 14 public: public:
16 15 typedef T event_type; typedef T event_type;
17 16 typedef std::function<void(U...)> callback_type; typedef std::function<void(U...)> callback_type;
 
... ... namespace control {
24 23 void removeListeners(event_type) override; void removeListeners(event_type) override;
25 24 void removeAllListeners() override; void removeAllListeners() override;
26 25
27 void interupt(event_type, U ...) override;
28 private:
26 void interupt(event_type, U...) override;
27
28 private:
29 29 typedef std::map<event_type, batch_type> map_type; typedef std::map<event_type, batch_type> map_type;
30 30 void kill_all(map_type&); void kill_all(map_type&);
31 31
File src/emitter_impl.hxx changed (mode: 100644) (index 50dae9f..8b1bc11)
... ... namespace om636 {
2 2 namespace control { namespace control {
3 3
4 4 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
5 template <typename T, typename ... U>
6 auto EmitterImpl<T, U ...>::on(event_type e, callback_type c) -> listener_type
5 template <typename T, typename... U>
6 auto EmitterImpl<T, U...>::on(event_type e, callback_type c) -> listener_type
7 7 { {
8 8 return m_repeat[e].hook(c); return m_repeat[e].hook(c);
9 9 } }
10 10
11 11 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
12 template <typename T, typename ... U>
13 auto EmitterImpl<T, U ...>::once(event_type e, callback_type c) -> listener_type
12 template <typename T, typename... U>
13 auto EmitterImpl<T, U...>::once(event_type e, callback_type c) -> listener_type
14 14 { {
15 15 return m_once[e].hook(c); return m_once[e].hook(c);
16 16 } }
17 17
18 18 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
19 template <typename T, typename ... U>
20 void EmitterImpl<T, U ...>::removeListeners(event_type e)
19 template <typename T, typename... U>
20 void EmitterImpl<T, U...>::removeListeners(event_type e)
21 21 { {
22 22 m_once[e].unhook(); m_once[e].unhook();
23 23 m_repeat[e].unhook(); m_repeat[e].unhook();
24 24 } }
25 25
26 26 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
27 template <typename T, typename ... U>
28 void EmitterImpl<T, U ...>::removeAllListeners()
27 template <typename T, typename... U>
28 void EmitterImpl<T, U...>::removeAllListeners()
29 29 { {
30 30 kill_all(m_once); kill_all(m_once);
31 31 kill_all(m_repeat); kill_all(m_repeat);
32 32 } }
33 33
34 34 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
35 template <typename T, typename ... U>
36 void EmitterImpl<T, U ...>::interupt(event_type e, U ... arg)
35 template <typename T, typename... U>
36 void EmitterImpl<T, U...>::interupt(event_type e, U... arg)
37 37 { {
38 38 m_once[e].merge_added_elements(); m_once[e].merge_added_elements();
39 39 m_repeat[e].merge_added_elements(); m_repeat[e].merge_added_elements();
40 40
41 utils::process_and_kill(m_once[e].elements(), arg ... );
42 utils::process(m_repeat[e].elements(), arg ... );
41 utils::process_and_kill(m_once[e].elements(), arg...);
42 utils::process(m_repeat[e].elements(), arg...);
43 43 } }
44 44
45 45 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
46 template <typename T, typename ... U>
47 void EmitterImpl<T, U ...>::kill_all(map_type& map)
46 template <typename T, typename... U>
47 void EmitterImpl<T, U...>::kill_all(map_type& map)
48 48 { {
49 49 for_each(map.begin(), map.end(), [](typename map_type::value_type& p) { for_each(map.begin(), map.end(), [](typename map_type::value_type& p) {
50 50 p.second.unhook(); p.second.unhook();
File src/interface.h changed (mode: 100644) (index 30575ea..be31d9d)
10 10
11 11 namespace om636 { namespace om636 {
12 12 namespace control { namespace control {
13
14 template <typename T, typename ... U>
13
14 template <typename T, typename... U>
15 15 class Emitter { class Emitter {
16 16 public: public:
17 17 typedef T event_type; typedef T event_type;
 
... ... namespace control {
27 27 virtual void removeListeners(event_type) = 0; virtual void removeListeners(event_type) = 0;
28 28 virtual void removeAllListeners() = 0; virtual void removeAllListeners() = 0;
29 29
30 virtual void interupt(event_type, U ...) = 0;
30 virtual void interupt(event_type, U...) = 0;
31 31 }; };
32
33 template <typename T, typename ... U>
34 class Quemitter : public Emitter<T, U ...>
35 {
36
32
33 template <typename T, typename... U>
34 class Quemitter : public Emitter<T, U...> {
35
37 36 public: public:
38 typedef Emitter<T, U ...> base_type;
39 using typename base_type::event_type;
40 using typename base_type::callback_type;
37 typedef Emitter<T, U...> base_type;
41 38 using typename base_type::batch_type; using typename base_type::batch_type;
39 using typename base_type::callback_type;
40 using typename base_type::event_type;
42 41 using typename base_type::listener_type; using typename base_type::listener_type;
43 42
44 43 virtual ~Quemitter() = default; virtual ~Quemitter() = default;
45 virtual void emit(event_type, U ...) = 0;
44 virtual void emit(event_type, U...) = 0;
46 45 }; };
47 46
48 47 } //control } //control
File src/quemitter.h changed (mode: 100644) (index c6dd1cd..5a1be8b)
... ... namespace control {
18 18 class Quemitter class Quemitter
19 19 : public Emitter<T, U> { : public Emitter<T, U> {
20 20
21 typedef P<Quemitter<T, U, P> > fbp;
21 typedef P<Quemitter<T, U, P>> fbp;
22 22
23 23 public: public:
24 24 typedef Emitter<T, U> base_type; typedef Emitter<T, U> base_type;
25 using typename base_type::event_type;
26 25 using typename base_type::callback_type; using typename base_type::callback_type;
26 using typename base_type::event_type;
27 27 using typename base_type::listener_type; using typename base_type::listener_type;
28 28
29 29 Quemitter() = default; Quemitter() = default;
 
... ... namespace control {
31 31 Quemitter(const Quemitter&) = delete; Quemitter(const Quemitter&) = delete;
32 32 Quemitter& operator=(const Quemitter&) = delete; Quemitter& operator=(const Quemitter&) = delete;
33 33
34 template <class ... V>
35 void emit(event_type, V ...);
34 template <class... V>
35 void emit(event_type, V...);
36 36
37 37 private: private:
38 38 typedef std::function<void()> function_type; typedef std::function<void()> function_type;
File src/quemitter_impl.h changed (mode: 100644) (index e5ed9b0..5ce6817)
... ... namespace control {
16 16 static void unlocked_mutex(const T&) {} static void unlocked_mutex(const T&) {}
17 17 }; };
18 18
19
20 template <class T, template <typename> class P, typename ... U>
19 template <class T, template <typename> class P, typename... U>
21 20 class QuemitterImpl class QuemitterImpl
22 : public Quemitter<T, U ...>
23 {
24 typedef Quemitter<T, U ...> base_type;
25
21 : public Quemitter<T, U...> {
22 typedef Quemitter<T, U...> base_type;
23
26 24 public: public:
27 using typename base_type::event_type;
28 25 using typename base_type::callback_type; using typename base_type::callback_type;
26 using typename base_type::event_type;
29 27 using typename base_type::listener_type; using typename base_type::listener_type;
30
28
31 29 listener_type on(event_type, callback_type) override; listener_type on(event_type, callback_type) override;
32 30 listener_type once(event_type, callback_type) override; listener_type once(event_type, callback_type) override;
33 31
34 32 void removeListeners(event_type) override; void removeListeners(event_type) override;
35 33 void removeAllListeners() override; void removeAllListeners() override;
36 34
37 void interupt(event_type, U ...) override;
38 void emit(event_type, U ...) override;
35 void interupt(event_type, U...) override;
36 void emit(event_type, U...) override;
39 37
40 38 private: private:
41 typedef P<QuemitterImpl<T, P, U ...> > fbp;
42 typedef std::function<void()> function_type;
39 typedef P<QuemitterImpl<T, P, U...>> fbp;
40 typedef std::function<void()> function_type;
43 41 typedef om636::queue<function_type> queue_type; typedef om636::queue<function_type> queue_type;
44 42 typedef std::mutex mutex_type; typedef std::mutex mutex_type;
45 43
46 44 void push_event(function_type); void push_event(function_type);
47
48 EmitterImpl<T, U ...> m_reactor;
45
46 EmitterImpl<T, U...> m_reactor;
49 47 queue_type m_queue; queue_type m_queue;
50 48 mutex_type m_mutex; mutex_type m_mutex;
51 49 }; };
File src/quemitter_impl.hxx changed (mode: 100644) (index 94c636f..c8769a2)
1 1 namespace om636 { namespace om636 {
2 2 namespace control { namespace control {
3
3
4 4 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
5 template <typename T, template <typename> class P, typename ... U>
6 auto QuemitterImpl<T, P, U ...>::on(event_type e, callback_type c) -> listener_type
5 template <typename T, template <typename> class P, typename... U>
6 auto QuemitterImpl<T, P, U...>::on(event_type e, callback_type c) -> listener_type
7 7 { {
8 8 return m_reactor.on(e, c); return m_reactor.on(e, c);
9 9 } }
10 10
11 11 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
12 template <typename T, template <typename> class P, typename ... U>
13 auto QuemitterImpl<T, P, U ...>::once(event_type e, callback_type c) -> listener_type
12 template <typename T, template <typename> class P, typename... U>
13 auto QuemitterImpl<T, P, U...>::once(event_type e, callback_type c) -> listener_type
14 14 { {
15 15 return m_reactor.once(e, c); return m_reactor.once(e, c);
16 16 } }
17 17
18 18 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
19 template <typename T, template <typename> class P, typename ... U>
20 void QuemitterImpl<T, P, U ...>::removeListeners(event_type e)
19 template <typename T, template <typename> class P, typename... U>
20 void QuemitterImpl<T, P, U...>::removeListeners(event_type e)
21 21 { {
22 22 m_reactor.removeListeners(e); m_reactor.removeListeners(e);
23 23 } }
24 24
25 25 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
26 template <typename T, template <typename> class P, typename ... U>
27 void QuemitterImpl<T, P, U ...>::removeAllListeners()
26 template <typename T, template <typename> class P, typename... U>
27 void QuemitterImpl<T, P, U...>::removeAllListeners()
28 28 { {
29 m_reactor.removeAllListeners();
29 m_reactor.removeAllListeners();
30 30 } }
31 31
32 32 ///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
33 template <typename T, template <typename> class P, typename ... U>
34 void QuemitterImpl<T, P, U ...>::interupt(event_type e, U ... arg)
33 template <typename T, template <typename> class P, typename... U>
34 void QuemitterImpl<T, P, U...>::interupt(event_type e, U... arg)
35 35 { {
36 m_reactor.interupt(e, arg ...);
36 m_reactor.interupt(e, arg...);
37 37 } }
38 38
39
40 39 ///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
41 template <typename T, template <typename> class P, typename ... U>
42 void QuemitterImpl<T, P, U ...>::emit(event_type e, U ... v)
40 template <typename T, template <typename> class P, typename... U>
41 void QuemitterImpl<T, P, U...>::emit(event_type e, U... v)
43 42 { {
44 function_type p([e, v ..., this]() {
45 interupt(e, v ...);
43 function_type p([e, v..., this]() {
44 interupt(e, v...);
46 45 }); });
47 46
48 47 push_event(p); push_event(p);
49 48 } }
50 49
51 50 ///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
52 template <class T, template <typename> class P, typename ... U>
53 void QuemitterImpl<T, P, U ...>::push_event(function_type f)
51 template <class T, template <typename> class P, typename... U>
52 void QuemitterImpl<T, P, U...>::push_event(function_type f)
54 53 { {
55 54 m_queue.push(f); m_queue.push(f);
56 55 fbp::pushed_event(*this); fbp::pushed_event(*this);
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/ohm

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

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

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