X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/9ed8b5a7b2e41ecb07d2dab32bac32eb7b771fd3..fba05595e6cca40763f8ead119c7ad61cb01e0e4:/include/wx/mac/corefoundation/cfref.h diff --git a/include/wx/mac/corefoundation/cfref.h b/include/wx/mac/corefoundation/cfref.h index 53d46e78c1..fb84f0fc5c 100644 --- a/include/wx/mac/corefoundation/cfref.h +++ b/include/wx/mac/corefoundation/cfref.h @@ -58,6 +58,92 @@ inline Type* wxCFRetain(Type *r) return r; } +template +class wxCFRef; + +/*! @class wxCFWeakRef + @templatefield refType The CF reference type (e.g. CFStringRef, CFRunLoopRef, etc.) + It should already be a pointer. This is different from + shared_ptr where the template parameter is the pointee type. + @discussion Wraps a raw pointer without any retain or release. + Provides a way to get what amounts to a raw pointer from a wxCFRef without + using a raw pointer. Unlike a raw pointer, constructing a wxCFRef from this + class will cause it to be retained because it is assumed that a wxCFWeakRef + does not own its pointer. +*/ +template +class wxCFWeakRef +{ + template + friend wxCFWeakRef static_cfref_cast(const wxCFRef &otherRef); +public: + /*! @method wxCFWeakRef + @abstract Creates a NULL reference + */ + wxCFWeakRef() + : m_ptr(NULL) + {} + + // Default copy constructor is fine. + // Default destructor is fine but we'll set NULL to avoid bugs + ~wxCFWeakRef() + { m_ptr = NULL; } + + // Do not implement a raw-pointer constructor. + + /*! @method wxCFWeakRef + @abstract Copies another ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by another wxCFWeakRef. + @param otherRef The other weak ref holder to copy. + @discussion This is merely a copy or implicit cast. + */ + template + wxCFWeakRef(const wxCFWeakRef& otherRef) + : m_ptr(otherRef.get()) // Implicit conversion from otherRefType to refType should occur + {} + + /*! @method wxCFWeakRef + @abstract Copies a strong ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by a wxCFRef. + @param otherRef The strong ref holder to copy. + @discussion This ref is merely a pointer copy, the strong ref still holds the pointer. + */ + template + wxCFWeakRef(const wxCFRef& otherRef) + : m_ptr(otherRef.get()) // Implicit conversion from otherRefType to refType should occur + {} + + /*! @method get + @abstract Explicit conversion to the underlying pointer type + @discussion Allows the caller to explicitly get the underlying pointer. + */ + refType get() const + { return m_ptr; } + + /*! @method operator refType + @abstract Implicit conversion to the underlying pointer type + @discussion Allows the ref to be used in CF function calls. + */ + operator refType() const + { return m_ptr; } + +protected: + /*! @method wxCFWeakRef + @abstract Constructs a weak reference to the raw pointer + @templatefield otherType Any type. + @param p The raw pointer to assume ownership of. May be NULL. + @discussion This method is private so that the friend static_cfref_cast can use it + */ + template + explicit wxCFWeakRef(otherType *p) + : m_ptr(p) // Implicit conversion from otherType* to refType should occur. + {} + + /*! @var m_ptr The raw pointer. + */ + refType m_ptr; +}; + /*! @class wxCFRef @templatefield refType The CF reference type (e.g. CFStringRef, CFRunLoopRef, etc.) It should already be a pointer. This is different from @@ -114,6 +200,19 @@ public: : m_ptr(wxCFRetain(otherRef.get())) // Implicit conversion from otherRefType to refType should occur {} + /*! @method wxCFRef + @abstract Copies a weak ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by a wxCFWeakRef. + @param otherRef The weak ref holder to copy. + @discussion Ownership will be taken by this newly created ref. That is, + the object will be explicitly retained by this new ref. + Ownership is most likely shared with some other ref as well. + */ + template + wxCFRef(const wxCFWeakRef& otherRef) + : m_ptr(wxCFRetain(otherRef.get())) // Implicit conversion from otherRefType to refType should occur + {} + /*! @method ~wxCFRef @abstract Releases (potentially shared) ownership of the ref. @discussion A ref holder instance is always assumed to have ownership so ownership is always @@ -225,21 +324,26 @@ inline wxCFRef wxCFRefFromGet(Type *p) } /*! @function static_cfref_cast - @abstract Works like static_cast but from one wxCFRef to another + @abstract Works like static_cast but with a wxCFRef as the argument. @param refType Template parameter. The destination raw pointer type @param otherRef Normal parameter. The source wxCFRef<> object. - @discussion This is modeled after shared_ptr's static_pointer_cast. Just as wxCFRef is + @discussion This is intended to be a clever way to make static_cast work while allowing + the return value to be converted to either a strong ref or a raw pointer + while ensuring that the retain count is updated appropriately. + + This is modeled after shared_ptr's static_pointer_cast. Just as wxCFRef is parameterized on a pointer to an opaque type so is this class. Note that this differs from shared_ptr which is parameterized on the pointee type. + FIXME: Anybody got a better name? */ template -inline wxCFRef static_cfref_cast(const wxCFRef &otherRef); +inline wxCFWeakRef static_cfref_cast(const wxCFRef &otherRef); template -inline wxCFRef static_cfref_cast(const wxCFRef &otherRef) +inline wxCFWeakRef static_cfref_cast(const wxCFRef &otherRef) { - return wxCFRef(static_cast(wxCFRetain(otherRef.get()))); + return wxCFWeakRef(static_cast(otherRef.get())); } /*! @function CFRelease