|
1
|
1 #pragma once
|
|
|
2
|
|
|
3 // service_impl.h
|
|
|
4 // This header provides functionality for spawning your own service objects.
|
|
|
5 // Various service_impl_* classes implement service_base methods (reference counting, query for interface) on top of your class.
|
|
|
6 // service_impl_* are top level ("sealed" in C# terms) classes; they derive from your classes but you should never derive from them.
|
|
|
7
|
|
|
8 #include <utility>
|
|
|
9
|
|
|
10 namespace service_impl_helper {
|
|
|
11 //! Helper function to defer destruction of a service object. \n
|
|
|
12 //! Enqueues a main_thread_callback to release the object at a later time, escaping the current scope. \n
|
|
|
13 //! Important: this takes a raw service_base* - not an autoptr - to ensure that the last reference can be released in main thread. \n
|
|
|
14 void release_object_delayed(service_base* obj);
|
|
|
15 };
|
|
|
16
|
|
|
17 //! Multi inheritance helper. \n
|
|
|
18 //! Please note that use of multi inheritance is not recommended. Most components will never need this. \n
|
|
|
19 //! This class handles multi inherited service_query() for you. \n
|
|
|
20 //! Usage: class myclass : public service_multi_inherit<interface1, interface2> {...}; \n
|
|
|
21 //! It's also legal to chain it: service_multi_inherit<interface1, service_multi_inherit<interface2, interface3> > and so on.
|
|
|
22 template<typename class1_t, typename class2_t>
|
|
|
23 class service_multi_inherit : public class1_t, public class2_t {
|
|
|
24 typedef service_multi_inherit<class1_t, class2_t> self_t;
|
|
|
25
|
|
|
26 template<typename sub1_t, typename sub2_t>
|
|
|
27 inline static bool service_query_this(service_ptr& out, const GUID& guid, service_multi_inherit<sub1_t, sub2_t>* in) {
|
|
|
28 return service_multi_inherit<sub1_t, sub2_t>::handle_service_query(out, guid, in);
|
|
|
29 }
|
|
|
30
|
|
|
31 template<typename class_t>
|
|
|
32 inline static bool service_query_this(service_ptr& out, const GUID& guid, class_t* in) {
|
|
|
33 return service_base::handle_service_query(out, guid, in);
|
|
|
34 }
|
|
|
35 public:
|
|
|
36
|
|
|
37 // template<typename sub1_t, typename sub2_t>
|
|
|
38
|
|
|
39
|
|
|
40 static bool handle_service_query(service_ptr & out, const GUID & guid, self_t * in) {
|
|
|
41 return service_query_this(out, guid, (class1_t*) in) || service_query_this(out, guid, (class2_t*) in);
|
|
|
42 }
|
|
|
43
|
|
|
44 service_base * as_service_base() { return class1_t::as_service_base(); }
|
|
|
45 static const char * debugServiceName() { return "multi inherited service"; }
|
|
|
46
|
|
|
47 // Obscure service_base methods from both so calling myclass->service_query() works like it should
|
|
|
48 virtual int service_release() throw() = 0;
|
|
|
49 virtual int service_add_ref() throw() = 0;
|
|
|
50 virtual bool service_query(service_ptr & p_out, const GUID & p_guid) = 0;
|
|
|
51
|
|
|
52 static bool serviceRequiresMainThreadDestructor() {
|
|
|
53 return class1_t::serviceRequiresMainThreadDestructor() || class2_t::serviceRequiresMainThreadDestructor();
|
|
|
54 }
|
|
|
55 };
|
|
|
56
|
|
|
57 //! Template implementing service_query walking the inheritance chain. \n
|
|
|
58 //! Do not use directly. Each service_impl_* template utilizes it implicitly.
|
|
|
59 template<typename class_t> class implement_service_query : public class_t
|
|
|
60 {
|
|
|
61 typedef class_t base_t;
|
|
|
62 public:
|
|
|
63 template<typename ... arg_t> implement_service_query( arg_t && ... arg ) : base_t( std::forward<arg_t>(arg) ... ) {}
|
|
|
64
|
|
|
65 bool service_query(service_ptr_t<service_base> & p_out, const GUID & p_guid) override {
|
|
|
66 return this->handle_service_query( p_out, p_guid, this );
|
|
|
67 }
|
|
|
68 };
|
|
|
69
|
|
|
70 //! Template implementing reference-counting features of service_base. Intended for dynamic instantiation: "new service_impl_t<someclass>(param1,param2);"; should not be instantiated otherwise (no local/static/member objects) because it does a "delete this;" when reference count reaches zero. \n
|
|
|
71 //! Note that there's no more need to use this direclty, see fb2k::service_new<>().
|
|
|
72 template<typename class_t>
|
|
|
73 class service_impl_t : public implement_service_query<class_t>
|
|
|
74 {
|
|
|
75 typedef implement_service_query<class_t> base_t;
|
|
|
76 public:
|
|
|
77 int service_release() throw() {
|
|
|
78 int ret = (int) --m_counter;
|
|
|
79 if (ret == 0) {
|
|
|
80 if (!this->serviceRequiresMainThreadDestructor() || core_api::is_main_thread()) {
|
|
|
81 PFC_ASSERT_NO_EXCEPTION( delete this );
|
|
|
82 } else {
|
|
|
83 // Pass to release_object_delayed() with zero ref count - a temporary single reference will be created there
|
|
|
84 service_impl_helper::release_object_delayed(this->as_service_base());
|
|
|
85 }
|
|
|
86 }
|
|
|
87 return ret;
|
|
|
88 }
|
|
|
89 int service_add_ref() throw() {return (int) ++m_counter;}
|
|
|
90
|
|
|
91 template<typename ... arg_t> service_impl_t( arg_t && ... arg ) : base_t( std::forward<arg_t>(arg) ... ) {}
|
|
|
92 private:
|
|
|
93 pfc::refcounter m_counter;
|
|
|
94 };
|
|
|
95
|
|
|
96 //! Alternate version of service_impl_t<> - calls this->service_shutdown() instead of delete this. \n
|
|
|
97 //! For special cases where selfdestruct on zero refcount is undesired.
|
|
|
98 template<typename class_t>
|
|
|
99 class service_impl_explicitshutdown_t : public implement_service_query<class_t>
|
|
|
100 {
|
|
|
101 typedef implement_service_query<class_t> base_t;
|
|
|
102 public:
|
|
|
103 int service_release() throw() {
|
|
|
104 int ret = --m_counter;
|
|
|
105 if (ret == 0) {
|
|
|
106 this->service_shutdown();
|
|
|
107 } else {
|
|
|
108 return ret;
|
|
|
109 }
|
|
|
110 }
|
|
|
111 int service_add_ref() throw() {return ++m_counter;}
|
|
|
112
|
|
|
113 template<typename ... arg_t> service_impl_explicitshutdown_t(arg_t && ... arg) : base_t(std::forward<arg_t>(arg) ...) {}
|
|
|
114 private:
|
|
|
115 pfc::refcounter m_counter;
|
|
|
116 };
|
|
|
117
|
|
|
118 //! Template implementing dummy version of reference-counting features of service_base. Intended for static/local/member instantiation: "static service_impl_single_t<someclass> myvar(params);". Because reference counting features are disabled (dummy reference counter), code instantiating it is responsible for deleting it as well as ensuring that no references are active when the object gets deleted.\n
|
|
|
119 template<typename class_t>
|
|
|
120 class service_impl_single_t : public implement_service_query<class_t>
|
|
|
121 {
|
|
|
122 typedef implement_service_query<class_t> base_t;
|
|
|
123 public:
|
|
|
124 int service_release() throw() {return 1;}
|
|
|
125 int service_add_ref() throw() {return 1;}
|
|
|
126
|
|
|
127 template<typename ... arg_t> service_impl_single_t(arg_t && ... arg) : base_t(std::forward<arg_t>(arg) ...) {}
|
|
|
128 };
|
|
|
129
|
|
|
130 namespace fb2k {
|
|
|
131 //! The new recommended way of spawning service objects, automatically implementing reference counting and service_query on top of your class. \n
|
|
|
132 //! Usage: auto myObj = fb2k::service_new<myClass>(args); \n
|
|
|
133 //! Returned type is a service_ptr_t<myClass>
|
|
|
134 template<typename obj_t, typename ... arg_t>
|
|
|
135 service_ptr_t<obj_t> service_new(arg_t && ... arg) {
|
|
|
136 return new service_impl_t< obj_t > ( std::forward<arg_t> (arg) ... );
|
|
|
137 }
|
|
|
138 }
|
|
|
139
|
|
|
140 #define FB2K_SERVICE_SINGLETON(class_t) PFC_SINGLETON( service_impl_single_t< class_t> ) |
