libzypp  17.36.7
base.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \----------------------------------------------------------------------/
9 *
10 * This file contains private API, this might break at any time between releases.
11 * You have been warned!
12 *
13 */
14 #ifndef ZYPP_NG_BASE_BASE_H_INCLUDED
15 #define ZYPP_NG_BASE_BASE_H_INCLUDED
16 
19 #include <memory>
20 #include <unordered_set>
21 #include <vector>
22 #include <thread>
23 
24 namespace zyppng {
25 
26  class Base;
27  class BasePrivate;
28 
29  namespace internal {
30  template <typename Func>
32 
33  template <typename BType, typename Ret, typename ...Args >
34  struct MemberFunction<Ret (BType::*)( Args... )> {
35  using ClassType = BType;
36  };
37 
38  template <typename T>
39  inline constexpr bool is_base_receiver = std::is_base_of_v<Base, T> || std::is_base_of_v<BasePrivate, T>;
40 
41  }
42 
59  class LIBZYPP_NG_EXPORT Base : public sigc::trackable, public std::enable_shared_from_this<Base>
60  {
63  public:
64 
65  using Ptr = std::shared_ptr<Base>;
66  using WeakPtr = std::weak_ptr<Base>;
67 
68  Base ();
69  virtual ~Base();
70 
75  WeakPtr parent() const;
76 
81  void addChild ( const Base::Ptr& child );
82 
86  void removeChild (const Ptr& child );
87 
91  const std::unordered_set<Ptr> &children() const;
92 
96  std::thread::id threadId () const;
97 
101  template<typename T>
102  std::vector< std::weak_ptr<T> > findChildren () const {
103  std::vector< std::weak_ptr<T> > result;
104  for ( const Ptr& p : children() ) {
105  std::shared_ptr<T> casted = std::dynamic_pointer_cast<T>(p);
106  if ( casted )
107  result.push_back( std::weak_ptr<T>(casted) );
108  }
109  return result;
110  }
111 
112  template<typename T>
113  inline std::shared_ptr<T> shared_this () const {
114  return std::static_pointer_cast<T>( shared_from_this() );
115  }
116 
117  template<typename T>
118  inline std::shared_ptr<T> shared_this () {
119  return std::static_pointer_cast<T>( shared_from_this() );
120  }
121 
122  template<typename T>
123  inline std::weak_ptr<T> weak_this () const {
124  return std::static_pointer_cast<T>( weak_from_this().lock() );
125  }
126 
127  template<typename T>
128  inline std::weak_ptr<T> weak_this () {
129  return std::static_pointer_cast<T>( weak_from_this().lock() );
130  }
131 
132  template<typename Obj, typename Functor >
133  static decltype (auto) make_base_slot( Obj *o, Functor &&f ) {
134  //static_assert ( !internal::is_base_receiver<Obj>, "Can not make a slot for a Object that does not derive from Base or BasePrivate.");
135  return internal::locking_fun( sigc::mem_fun( o, std::forward<Functor>(f) ), *o );
136  }
137 
141  template< typename SenderFunc, typename ReceiverFunc >
142  static auto connect ( typename internal::MemberFunction<SenderFunc>::ClassType &s, SenderFunc &&sFun, typename internal::MemberFunction<ReceiverFunc>::ClassType &recv, ReceiverFunc &&rFunc ) {
143  return std::invoke( std::forward<SenderFunc>(sFun), &s ).connect( make_base_slot( &recv, std::forward<ReceiverFunc>(rFunc) ) );
144  }
145 
146 
153  template< typename SenderFunc, typename ReceiverFunc >
154  auto connect ( SenderFunc &&sFun, typename internal::MemberFunction<ReceiverFunc>::ClassType &recv, ReceiverFunc &&rFunc ) {
155  return connect( static_cast<typename internal::MemberFunction<SenderFunc>::ClassType &>(*this), std::forward<SenderFunc>(sFun), recv, std::forward<ReceiverFunc>(rFunc) );
156  }
157 
162  template< typename SenderFunc, typename ReceiverFunc, typename ...Tracker >
163  static auto connectFunc ( typename internal::MemberFunction<SenderFunc>::ClassType &s, SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker&...trackers ) {
164  return std::invoke( std::forward<SenderFunc>(sFun), &s ).connect( internal::locking_fun( std::forward<ReceiverFunc>(rFunc), trackers... ) );
165  }
166 
167  template< typename SenderFunc, typename ReceiverFunc, typename ...Tracker >
168  std::enable_if_t< std::is_member_function_pointer_v< SenderFunc >, connection > connectFunc ( SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker&...trackers ) {
169  return connectFunc( static_cast<typename internal::MemberFunction<SenderFunc>::ClassType &>(*this), std::forward<SenderFunc>(sFun), std::forward<ReceiverFunc>(rFunc), trackers... );
170  }
171 
172  protected:
173  Base ( BasePrivate &dd );
174  std::unique_ptr<BasePrivate> d_ptr;
175  };
176 
177 
178  template<typename Obj, typename Functor,
179  std::enable_if_t< std::is_base_of_v< Base, Obj> || std::is_base_of_v<BasePrivate, Obj>, bool> = true
180  >
181  inline decltype(auto) base_slot( Obj *o, Functor &&f )
182  {
183  return Base::make_base_slot(o, std::forward<Functor>(f) );
184  }
185 
186  template<typename Obj, typename Functor,
187  std::enable_if_t< std::is_base_of_v< Base, Obj> || std::is_base_of_v<BasePrivate, Obj>, bool> = true
188  >
189  inline decltype(auto) base_slot( Obj &o, Functor &&f )
190  {
191  return Base::make_base_slot(&o, std::forward<Functor>(f) );
192  }
193 
194 } // namespace zyppng
195 
196 #endif // ZYPP_NG_CORE_BASE_H_INCLUDED
decltype(auto) base_slot(Obj *o, Functor &&f)
Definition: base.h:181
std::weak_ptr< Base > WeakPtr
Definition: base.h:66
std::enable_if< std::is_member_pointer< typename std::decay< Functor >::type >::value, typename std::result_of< Functor &&(Args &&...)>::type >::type invoke(Functor &&f, Args &&... args)
Definition: functional.h:32
std::shared_ptr< T > shared_this()
Definition: base.h:118
std::vector< std::weak_ptr< T > > findChildren() const
Definition: base.h:102
typename enable_if< B, T >::type enable_if_t
Definition: TypeTraits.h:45
static auto connect(typename internal::MemberFunction< SenderFunc >::ClassType &s, SenderFunc &&sFun, typename internal::MemberFunction< ReceiverFunc >::ClassType &recv, ReceiverFunc &&rFunc)
Definition: base.h:142
std::enable_if_t< std::is_member_function_pointer_v< SenderFunc >, connection > connectFunc(SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker &...trackers)
Definition: base.h:168
std::weak_ptr< T > weak_this() const
Definition: base.h:123
static decltype(auto) make_base_slot(Obj *o, Functor &&f)
Definition: base.h:133
auto connect(SenderFunc &&sFun, typename internal::MemberFunction< ReceiverFunc >::ClassType &recv, ReceiverFunc &&rFunc)
Definition: base.h:154
sigc::connection connection
Definition: signals.h:180
#define ZYPP_DECLARE_PRIVATE(Class)
Definition: zyppglobal.h:87
static auto connectFunc(typename internal::MemberFunction< SenderFunc >::ClassType &s, SenderFunc &&sFun, ReceiverFunc &&rFunc, const Tracker &...trackers)
Definition: base.h:163
constexpr bool is_base_receiver
Definition: base.h:39
#define LIBZYPP_NG_EXPORT
Definition: zyppglobal.h:8
#define NON_COPYABLE(CLASS)
Delete copy ctor and copy assign.
Definition: Easy.h:49
decltype(auto) locking_fun(const Functor &f, const Obj &... o)
Definition: signals.h:316
std::unique_ptr< BasePrivate > d_ptr
Definition: base.h:174
sigc::trackable trackable
Definition: signals.h:181
std::weak_ptr< T > weak_this()
Definition: base.h:128
std::shared_ptr< T > shared_this() const
Definition: base.h:113
std::shared_ptr< Base > Ptr
Definition: base.h:65