1 //===-- CFCReleaser.h -------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H 10 #define LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H 11 12 #include <CoreFoundation/CoreFoundation.h> 13 14 #include <cassert> 15 16 // Templatized CF helper class that can own any CF pointer and will 17 // call CFRelease() on any valid pointer it owns unless that pointer is 18 // explicitly released using the release() member function. This class 19 // is designed to mimic the std::auto_ptr<T> class and has all of the 20 // same functions. The one thing to watch out for is the 21 // CFCReleaser<T>::release() function won't actually CFRelease any owned 22 // pointer, it is designed to relinquish ownership of the pointer just 23 // like std:auto_ptr<T>::release() does. 24 template <class T> class CFCReleaser { 25 public: 26 // Constructor that takes a pointer to a CF object that is 27 // to be released when this object goes out of scope _ptr(ptr)28 CFCReleaser(T ptr = NULL) : _ptr(ptr) {} 29 30 // Copy constructor 31 // 32 // Note that copying a CFCReleaser will not transfer 33 // ownership of the contained pointer, but it will bump its 34 // reference count. This is where this class differs from 35 // std::auto_ptr. CFCReleaser(const CFCReleaser & rhs)36 CFCReleaser(const CFCReleaser &rhs) : _ptr(rhs.get()) { 37 if (get()) 38 ::CFRetain(get()); 39 } 40 41 // The destructor will release the pointer that it contains 42 // if it has a valid pointer. ~CFCReleaser()43 virtual ~CFCReleaser() { reset(); } 44 45 // Assignment operator. 46 // 47 // Note that assigning one CFCReleaser to another will 48 // not transfer ownership of the contained pointer, but it 49 // will bump its reference count. This is where this class 50 // differs from std::auto_ptr. 51 CFCReleaser &operator=(const CFCReleaser<T> &rhs) { 52 if (this != &rhs) { 53 // Replace our owned pointer with the new one 54 reset(rhs.get()); 55 // Retain the current pointer that we own 56 if (get()) 57 ::CFRetain(get()); 58 } 59 return *this; 60 } 61 62 // Get the address of the contained type in case it needs 63 // to be passed to a function that will fill in a pointer 64 // value. The function currently will assert if _ptr is not 65 // NULL because the only time this method should be used is 66 // if another function will modify the contents, and we 67 // could leak a pointer if this is not NULL. If the 68 // assertion fires, check the offending code, or call 69 // reset() prior to using the "ptr_address()" member to make 70 // sure any owned objects has CFRelease called on it. 71 // I had to add the "enforce_null" bool here because some 72 // API's require the pointer address even though they don't change it. 73 T *ptr_address(bool enforce_null = true) { 74 if (enforce_null) 75 assert(_ptr == NULL); 76 return &_ptr; 77 } 78 79 // Access the pointer itself get()80 T get() { return _ptr; } 81 get()82 const T get() const { return _ptr; } 83 84 // Set a new value for the pointer and CFRelease our old 85 // value if we had a valid one. 86 void reset(T ptr = NULL) { 87 if ((_ptr != NULL) && (ptr != _ptr)) 88 ::CFRelease(_ptr); 89 _ptr = ptr; 90 } 91 92 // Release ownership without calling CFRelease. This class 93 // is designed to mimic std::auto_ptr<T>, so the release 94 // method releases ownership of the contained pointer 95 // and does NOT call CFRelease. release()96 T release() { 97 T tmp = _ptr; 98 _ptr = NULL; 99 return tmp; 100 } 101 102 private: 103 T _ptr; 104 }; 105 106 #endif // LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H 107