Mercurial > foo_out_sdl

comparison foosdk/sdk/pfc/syncd_storage.h @ 1:20d02a178406 default tip

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
*: check in everything else yay
author Paper <paper@tflc.us>
date Mon, 05 Jan 2026 02:15:46 -0500
parents
children
comparison
equal deleted inserted replaced
0:e9bb126753e7 1:20d02a178406
1 #pragma once
2 #include "synchro.h"
3
4 namespace pfc {
5 // Read/write lock guarded object store for safe concurrent access
6 template<typename t_object>
7 class syncd_storage {
8 private:
9 typedef syncd_storage<t_object> t_self;
10 public:
11 syncd_storage() {}
12 template<typename t_source>
13 syncd_storage(const t_source & p_source) : m_object(p_source) {}
14 template<typename t_source>
15 void set(t_source && p_in) {
16 inWriteSync(m_sync);
17 m_object = std::forward<t_source>( p_in );
18 }
19 template<typename t_destination>
20 void get(t_destination & p_out) const {
21 inReadSync(m_sync);
22 p_out = m_object;
23 }
24 t_object get() const {
25 inReadSync(m_sync);
26 return m_object;
27 }
28 template<typename t_source>
29 const t_self & operator=(t_source && p_source) {set(std::forward<t_source>(p_source)); return *this;}
30 private:
31 mutable ::pfc::readWriteLock m_sync;
32 t_object m_object;
33 };
34
35 // Read/write lock guarded object store for safe concurrent access
36 // With 'has changed since last read' flag
37 template<typename t_object>
38 class syncd_storage_flagged {
39 private:
40 typedef syncd_storage_flagged<t_object> t_self;
41 public:
42 syncd_storage_flagged() : m_changed_flag(false) {}
43 template<typename t_source>
44 syncd_storage_flagged(const t_source & p_source, bool initChanged = false) : m_changed_flag(initChanged), m_object(p_source) {}
45 void set_changed(bool p_flag = true) {
46 inWriteSync(m_sync);
47 m_changed_flag = p_flag;
48 }
49 template<typename t_source>
50 void set(t_source && p_in) {
51 inWriteSync(m_sync);
52 m_object = std::forward<t_source>(p_in);
53 m_changed_flag = true;
54 }
55 bool has_changed() const {
56 // No point in locking here
57 // inReadSync(m_sync);
58 return m_changed_flag;
59 }
60 t_object peek() const {inReadSync(m_sync); return m_object;}
61 template<typename t_destination>
62 bool get_if_changed(t_destination & p_out) {
63 inReadSync(m_sync);
64 if (m_changed_flag) {
65 p_out = m_object;
66 m_changed_flag = false;
67 return true;
68 } else {
69 return false;
70 }
71 }
72 t_object get() {
73 inReadSync(m_sync);
74 m_changed_flag = false;
75 return m_object;
76 }
77 t_object get( bool & bHasChanged ) {
78 inReadSync(m_sync);
79 bHasChanged = m_changed_flag;
80 m_changed_flag = false;
81 return m_object;
82 }
83 template<typename t_destination>
84 void get(t_destination & p_out) {
85 inReadSync(m_sync);
86 p_out = m_object;
87 m_changed_flag = false;
88 }
89 template<typename t_source>
90 const t_self & operator=(t_source && p_source) {set(std::forward<t_source>(p_source)); return *this;}
91
92 template<typename arg_t>
93 bool compare_and_set(arg_t&& arg) {
94 inWriteSync(m_sync);
95 bool ret = false;
96 if (arg != m_object) {
97 m_object = std::forward<arg_t>(arg);
98 m_changed_flag = true;
99 ret = true;
100 }
101 return ret;
102 }
103 private:
104 mutable volatile bool m_changed_flag;
105 mutable ::pfc::readWriteLock m_sync;
106 t_object m_object;
107 };
108
109 }