diff options
Diffstat (limited to 'glib')
| -rw-r--r-- | glib/glibmm.h | 1 | ||||
| -rw-r--r-- | glib/glibmm/filelist.am | 1 | ||||
| -rw-r--r-- | glib/glibmm/object.cc | 22 | ||||
| -rw-r--r-- | glib/glibmm/weakref.h | 463 |
4 files changed, 0 insertions, 487 deletions
diff --git a/glib/glibmm.h b/glib/glibmm.h index 153d65ef..dcff5465 100644 --- a/glib/glibmm.h +++ b/glib/glibmm.h @@ -145,7 +145,6 @@ #include <glibmm/variantiter.h> #include <glibmm/varianttype.h> #include <glibmm/vectorutils.h> -#include <glibmm/weakref.h> #include <glibmm/wrap.h> #endif /* _GLIBMM_H */ diff --git a/glib/glibmm/filelist.am b/glib/glibmm/filelist.am index afeb2b4c..482527cc 100644 --- a/glib/glibmm/filelist.am +++ b/glib/glibmm/filelist.am @@ -80,7 +80,6 @@ glibmm_files_extra_h = \ value.h \ value_custom.h \ vectorutils.h \ - weakref.h \ wrap.h \ wrap_init.h diff --git a/glib/glibmm/object.cc b/glib/glibmm/object.cc index 19f30d53..cb5e50b2 100644 --- a/glib/glibmm/object.cc +++ b/glib/glibmm/object.cc @@ -27,28 +27,6 @@ #include <string.h> -// Weak references: -// I'm not sure what the point of these are apart from being a hacky way out of circular references, -// but maybe we could make it easier to use them by making a Java Reference Object -style class like -// so: -// Glib::WeakRef<SomeDerivedObject> weakrefSomeObject(object1); -// ... -// if(weakrefSomeObject->isStillAlive()) -// { -// weakrefSomeObject->some_method(); -// } -// else -// { -// //Deal with it, maybe recreating the object. -// } -// -// Without this, the coder has to define his own signal handler which sets his own isStillAlive -// boolean. -// weakrefSomeObject<> could still have its own signal_destroyed signal so that coders can choose to -// deal -// with the destruction as soon as it happens instead of just checking later before they try to use -// it. - namespace Glib { diff --git a/glib/glibmm/weakref.h b/glib/glibmm/weakref.h deleted file mode 100644 index b03c3273..00000000 --- a/glib/glibmm/weakref.h +++ /dev/null @@ -1,463 +0,0 @@ -#ifndef _GLIBMM_WEAKREF_H -#define _GLIBMM_WEAKREF_H - -/* Copyright (C) 2015 The glibmm Development Team - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see <http://www.gnu.org/licenses/>. - */ - -#include <glib-object.h> -#include <glibmm/refptr.h> -#include <glibmm/objectbase.h> -#include <type_traits> // std::is_base_of<> -#include <utility> // std::swap<>, std::forward<> - -namespace Glib -{ - -/** WeakRef<> is a weak reference smartpointer. - * - * WeakRef can store a pointer to any class that is derived from Glib::ObjectBase, - * and whose reference() method is noexcept. - * In glibmm and gtkmm, that is anything derived from Glib::ObjectBase. - * - * Unlike a RefPtr, a WeakRef does not contribute to the reference counting of - * the underlying object. - * - * @newin{2,46} - */ -template <typename T_CppObject> -class WeakRef -{ - static_assert(std::is_base_of<Glib::ObjectBase, T_CppObject>::value, - "Glib::WeakRef can be used only for classes derived from Glib::ObjectBase."); - -public: - /** Default constructor. - * - * Create an empty weak reference. - */ - inline WeakRef() noexcept; - - /// Copy constructor. - inline WeakRef(const WeakRef& src) noexcept; - - /// Move constructor. - inline WeakRef(WeakRef&& src) noexcept; - - /// Copy constructor from different, but castable type. - template <typename T_CastFrom> - inline WeakRef(const WeakRef<T_CastFrom>& src) noexcept; - - /// Move constructor from different, but castable type. - template <typename T_CastFrom> - inline WeakRef(WeakRef<T_CastFrom>&& src) noexcept; - - /** Constructor from a RefPtr of the same or a castable type. - * - * Create a weak reference from a RefPtr of the same or a castable type. - * If the RefPtr references nothing, an empty weak reference will be constructed. - */ - template <typename T_CastFrom> - inline WeakRef(const RefPtr<T_CastFrom>& src) noexcept; - - /// Destructor. - inline ~WeakRef() noexcept; - - /// Swap the contents of two WeakRef<>. - inline void swap(WeakRef& other) noexcept; - - /// Copy assignment operator. - inline WeakRef& operator=(const WeakRef& src) noexcept; - - /// Move assignment operator. - inline WeakRef& operator=(WeakRef&& src) noexcept; - - /// Copy assignment from different, but castable type. - template <typename T_CastFrom> - inline WeakRef& operator=(const WeakRef<T_CastFrom>& src) noexcept; - - /// Move assignment from different, but castable type. - template <typename T_CastFrom> - inline WeakRef& operator=(WeakRef<T_CastFrom>&& src) noexcept; - - /// Assignment from a RefPtr of the same or a castable type. - template <typename T_CastFrom> - inline WeakRef& operator=(const RefPtr<T_CastFrom>& src) noexcept; - - /** Test whether the WeakRef<> points to any underlying instance. - * - * Mimics usage of ordinary pointers: - * @code - * if (ptr) - * do_something(); - * @endcode - * - * In a multi-threaded program a <tt>true</tt> return value can become - * obsolete at any time, even before the caller has a chance to test it, - * because the underlying instance may lose its last reference in another - * thread. Use get() if this is not acceptable. - */ - inline explicit operator bool() const noexcept; - - /** Create a strong reference to the underlying object. - * - * This is a thread-safe way to acquire a strong reference to the underlying - * object. If the WeakRef is empty, the returned RefPtr will reference nothing. - */ - inline RefPtr<T_CppObject> get() const noexcept; - - /// Make this WeakRef empty. - inline void reset() noexcept; - - /** Dynamic cast to derived class. - * - * The WeakRef can't be cast with the usual notation so instead you can use - * @code - * ptr_derived = Glib::WeakRef<Derived>::cast_dynamic(ptr_base); - * @endcode - */ - template <typename T_CastFrom> - static inline WeakRef cast_dynamic(const WeakRef<T_CastFrom>& src) noexcept; - - /** Static cast to derived class. - * - * The WeakRef can't be cast with the usual notation so instead you can use - * @code - * ptr_derived = Glib::WeakRef<Derived>::cast_static(ptr_base); - * @endcode - */ - template <typename T_CastFrom> - static inline WeakRef cast_static(const WeakRef<T_CastFrom>& src) noexcept; - - /** Cast to non-const. - * - * The WeakRef can't be cast with the usual notation so instead you can use - * @code - * ptr_nonconst = Glib::WeakRef<NonConstType>::cast_const(ptr_const); - * @endcode - */ - template <typename T_CastFrom> - static inline WeakRef cast_const(const WeakRef<T_CastFrom>& src) noexcept; - -private: - // Let all instantiations of WeakRef access private data. - template <typename T_CastFrom> - friend class WeakRef; - - // If pCppObject != nullptr && gobject == nullptr, - // then the caller holds a strong reference. - void set(T_CppObject* pCppObject, GWeakRef* gobject) noexcept; - - // WeakRef owns *gobject_, but it does not own *pCppObject_. - // Invariant: (!pCppObject_ || gobject_), - // i.e. if pCppObject_ != nullptr then also gobject_ != nullptr. - T_CppObject* pCppObject_; - GWeakRef* gobject_; - - // Some methods would be simpler if gobject_ were a GWeakRef instead of - // a GWeakRef*, but then the move constructor and the move assignment - // operation would not be efficient. - -}; // end class WeakRef - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - -template <typename T_CppObject> -WeakRef<T_CppObject>::WeakRef() noexcept : pCppObject_(nullptr), gobject_(nullptr) -{ -} - -template <typename T_CppObject> -WeakRef<T_CppObject>::WeakRef(const WeakRef& src) noexcept : pCppObject_(src.pCppObject_), - gobject_(nullptr) -{ - if (pCppObject_) - { - // We must own a strong reference to the underlying GObject while - // calling g_weak_ref_init(). - gpointer ptr = g_weak_ref_get(src.gobject_); - if (ptr) - { - gobject_ = new GWeakRef; - g_weak_ref_init(gobject_, pCppObject_->gobj()); - g_object_unref(ptr); - } - else - pCppObject_ = nullptr; - } -} - -template <typename T_CppObject> -WeakRef<T_CppObject>::WeakRef(WeakRef&& src) noexcept : pCppObject_(src.pCppObject_), - gobject_(src.gobject_) -{ - src.pCppObject_ = nullptr; - src.gobject_ = nullptr; -} - -// The templated ctor allows copy construction from any object that's -// castable. Thus, it does downcasts: -// base_ref = derived_ref -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject>::WeakRef(const WeakRef<T_CastFrom>& src) noexcept - : pCppObject_(src.pCppObject_), - gobject_(nullptr) -{ - if (pCppObject_) - { - // We must own a strong reference to the underlying GObject while - // calling g_weak_ref_init(). - gpointer ptr = g_weak_ref_get(src.gobject_); - if (ptr) - { - gobject_ = new GWeakRef; - g_weak_ref_init(gobject_, pCppObject_->gobj()); - g_object_unref(ptr); - } - else - pCppObject_ = nullptr; - } -} - -// The templated ctor allows move construction from any object that's -// castable. Thus, it does downcasts: -// base_ref = std::move(derived_ref) -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject>::WeakRef(WeakRef<T_CastFrom>&& src) noexcept : pCppObject_(src.pCppObject_), - gobject_(src.gobject_) -{ - src.pCppObject_ = nullptr; - src.gobject_ = nullptr; -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject>::WeakRef(const RefPtr<T_CastFrom>& src) noexcept - : pCppObject_(src.get()), - gobject_(nullptr) -{ - if (pCppObject_) - { - gobject_ = new GWeakRef; - g_weak_ref_init(gobject_, pCppObject_->gobj()); - } -} - -template <typename T_CppObject> -WeakRef<T_CppObject>::~WeakRef() noexcept -{ - if (gobject_) - { - g_weak_ref_clear(gobject_); - delete gobject_; - } -} - -template <class T_CppObject> -void -WeakRef<T_CppObject>::swap(WeakRef& other) noexcept -{ - std::swap(pCppObject_, other.pCppObject_); - std::swap(gobject_, other.gobject_); -} - -template <typename T_CppObject> -WeakRef<T_CppObject>& -WeakRef<T_CppObject>::operator=(const WeakRef& src) noexcept -{ - set(src.pCppObject_, src.gobject_); - return *this; -} - -template <typename T_CppObject> -WeakRef<T_CppObject>& -WeakRef<T_CppObject>::operator=(WeakRef&& src) noexcept -{ - // This technique is inefficient for copy assignment of WeakRef, - // because it involves copy construction + destruction, i.e. in a typical - // case g_weak_ref_init() + g_weak_ref_clear(), when a g_weak_ref_set() - // would be enough. For move assignment, the swap technique is fine. - WeakRef<T_CppObject> temp(std::forward<WeakRef<T_CppObject>>(src)); - this->swap(temp); - return *this; -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject>& -WeakRef<T_CppObject>::operator=(const WeakRef<T_CastFrom>& src) noexcept -{ - set(src.pCppObject_, src.gobject_); - return *this; -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject>& -WeakRef<T_CppObject>::operator=(WeakRef<T_CastFrom>&& src) noexcept -{ - WeakRef<T_CppObject> temp(std::forward<WeakRef<T_CastFrom>>(src)); - this->swap(temp); - return *this; -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject>& -WeakRef<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src) noexcept -{ - T_CppObject* pCppObject = src.get(); - set(pCppObject, nullptr); - return *this; -} - -template <class T_CppObject> -WeakRef<T_CppObject>::operator bool() const noexcept -{ - if (!pCppObject_) - return false; - - gpointer ptr = g_weak_ref_get(gobject_); - if (!ptr) - return false; - - g_object_unref(ptr); - return true; -} - -template <typename T_CppObject> -RefPtr<T_CppObject> -WeakRef<T_CppObject>::get() const noexcept -{ - RefPtr<T_CppObject> ret; - - if (!pCppObject_) - return ret; - - gpointer ptr = g_weak_ref_get(gobject_); - if (!ptr) - return ret; - - // A RefPtr constructed from pointer expects reference to be done externally. - pCppObject_->reference(); - ret = make_refptr_for_instance<T_CppObject>(pCppObject_); - - g_object_unref(ptr); - - return ret; -} - -template <typename T_CppObject> -void -WeakRef<T_CppObject>::reset() noexcept -{ - set(nullptr, nullptr); -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject> -WeakRef<T_CppObject>::cast_dynamic(const WeakRef<T_CastFrom>& src) noexcept -{ - WeakRef<T_CppObject> ret; - - if (!src.pCppObject_) - return ret; - - gpointer ptr = g_weak_ref_get(src.gobject_); - if (!ptr) - return ret; - - // Don't call dynamic_cast<>() unless we know that the referenced object - // still exists. - T_CppObject* const pCppObject = dynamic_cast<T_CppObject*>(src.pCppObject_); - ret.set(pCppObject, nullptr); - g_object_unref(ptr); - - return ret; -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject> -WeakRef<T_CppObject>::cast_static(const WeakRef<T_CastFrom>& src) noexcept -{ - T_CppObject* const pCppObject = static_cast<T_CppObject*>(src.pCppObject_); - - WeakRef<T_CppObject> ret; - ret.set(pCppObject, src.gobject_); - return ret; -} - -template <typename T_CppObject> -template <typename T_CastFrom> -WeakRef<T_CppObject> -WeakRef<T_CppObject>::cast_const(const WeakRef<T_CastFrom>& src) noexcept -{ - T_CppObject* const pCppObject = const_cast<T_CppObject*>(src.pCppObject_); - - WeakRef<T_CppObject> ret; - ret.set(pCppObject, src.gobject_); - return ret; -} - -template <typename T_CppObject> -void -WeakRef<T_CppObject>::set(T_CppObject* pCppObject, GWeakRef* gobject) noexcept -{ - // We must own a strong reference to the underlying GObject while - // calling g_weak_ref_init() or g_weak_ref_set(). - // If pCppObject != nullptr && gobject == nullptr, - // then the caller holds a strong reference. - - // An aim with this moderately complicated method is to keep the same - // GWeakRef, calling g_weak_ref_set() when possible, instead of using swap(), - // which implies creating a new WeakRef, swapping with *this, and deleting - // the new WeakRef. - - gpointer ptr = nullptr; - if (pCppObject && gobject) - ptr = g_weak_ref_get(gobject); - - pCppObject_ = (ptr || !gobject) ? pCppObject : nullptr; - if (pCppObject_ && !gobject_) - { - gobject_ = new GWeakRef; - g_weak_ref_init(gobject_, pCppObject_->gobj()); - } - else if (gobject_) - g_weak_ref_set(gobject_, pCppObject_ ? pCppObject_->gobj() : nullptr); - - if (ptr) - g_object_unref(ptr); -} - -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Swap the contents of two WeakRef<>. - * @relates Glib::WeakRef - */ -template <class T_CppObject> -inline void -swap(WeakRef<T_CppObject>& lhs, WeakRef<T_CppObject>& rhs) noexcept -{ - lhs.swap(rhs); -} - -} // namespace Glib - -#endif // _GLIBMM_WEAKREF_H |