1251881Speter//===-- CFCReleaser.h -------------------------------------------*- C++ -*-===// 2251881Speter// 3251881Speter// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4251881Speter// See https://llvm.org/LICENSE.txt for license information. 5251881Speter// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6251881Speter// 7251881Speter//===----------------------------------------------------------------------===// 8251881Speter 9251881Speter#ifndef LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H 10251881Speter#define LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H 11251881Speter 12251881Speter#include <CoreFoundation/CoreFoundation.h> 13251881Speter 14251881Speter#ifdef __cplusplus 15251881Speter 16251881Speter#include <cassert> 17251881Speter 18251881Speter// Templatized CF helper class that can own any CF pointer and will 19251881Speter// call CFRelease() on any valid pointer it owns unless that pointer is 20251881Speter// explicitly released using the release() member function. This class 21251881Speter// is designed to mimic the std::auto_ptr<T> class and has all of the 22251881Speter// same functions. The one thing to watch out for is the 23251881Speter// CFCReleaser<T>::release() function won't actually CFRelease any owned 24251881Speter// pointer, it is designed to relinquish ownership of the pointer just 25251881Speter// like std:auto_ptr<T>::release() does. 26251881Spetertemplate <class T> class CFCReleaser { 27251881Speterpublic: 28251881Speter // Constructor that takes a pointer to a CF object that is 29251881Speter // to be released when this object goes out of scope 30251881Speter CFCReleaser(T ptr = NULL) : _ptr(ptr) {} 31251881Speter 32251881Speter // Copy constructor 33251881Speter // 34251881Speter // Note that copying a CFCReleaser will not transfer 35251881Speter // ownership of the contained pointer, but it will bump its 36251881Speter // reference count. This is where this class differs from 37251881Speter // std::auto_ptr. 38251881Speter CFCReleaser(const CFCReleaser &rhs) : _ptr(rhs.get()) { 39251881Speter if (get()) 40251881Speter ::CFRetain(get()); 41251881Speter } 42251881Speter 43251881Speter // The destructor will release the pointer that it contains 44251881Speter // if it has a valid pointer. 45251881Speter virtual ~CFCReleaser() { reset(); } 46251881Speter 47251881Speter // Assignment operator. 48251881Speter // 49251881Speter // Note that assigning one CFCReleaser to another will 50251881Speter // not transfer ownership of the contained pointer, but it 51251881Speter // will bump its reference count. This is where this class 52251881Speter // differs from std::auto_ptr. 53251881Speter CFCReleaser &operator=(const CFCReleaser<T> &rhs) { 54251881Speter if (this != &rhs) { 55251881Speter // Replace our owned pointer with the new one 56251881Speter reset(rhs.get()); 57251881Speter // Retain the current pointer that we own 58251881Speter if (get()) 59251881Speter ::CFRetain(get()); 60251881Speter } 61251881Speter return *this; 62251881Speter } 63251881Speter 64251881Speter // Get the address of the contained type in case it needs 65251881Speter // to be passed to a function that will fill in a pointer 66251881Speter // value. The function currently will assert if _ptr is not 67251881Speter // NULL because the only time this method should be used is 68251881Speter // if another function will modify the contents, and we 69251881Speter // could leak a pointer if this is not NULL. If the 70251881Speter // assertion fires, check the offending code, or call 71251881Speter // reset() prior to using the "ptr_address()" member to make 72251881Speter // sure any owned objects has CFRelease called on it. 73251881Speter // I had to add the "enforce_null" bool here because some 74251881Speter // API's require the pointer address even though they don't change it. 75251881Speter T *ptr_address(bool enforce_null = true) { 76251881Speter if (enforce_null) 77251881Speter assert(_ptr == NULL); 78251881Speter return &_ptr; 79251881Speter } 80251881Speter 81251881Speter // Access the pointer itself 82251881Speter T get() { return _ptr; } 83251881Speter 84251881Speter const T get() const { return _ptr; } 85251881Speter 86251881Speter // Set a new value for the pointer and CFRelease our old 87251881Speter // value if we had a valid one. 88251881Speter void reset(T ptr = NULL) { 89251881Speter if ((_ptr != NULL) && (ptr != _ptr)) 90251881Speter ::CFRelease(_ptr); 91251881Speter _ptr = ptr; 92251881Speter } 93251881Speter 94251881Speter // Release ownership without calling CFRelease. This class 95251881Speter // is designed to mimic std::auto_ptr<T>, so the release 96251881Speter // method releases ownership of the contained pointer 97251881Speter // and does NOT call CFRelease. 98251881Speter T release() { 99251881Speter T tmp = _ptr; 100251881Speter _ptr = NULL; 101251881Speter return tmp; 102251881Speter } 103251881Speter 104251881Speterprivate: 105251881Speter T _ptr; 106251881Speter}; 107251881Speter 108251881Speter#endif // #ifdef __cplusplus 109251881Speter#endif // LLDB_SOURCE_HOST_MACOSX_CFCPP_CFCRELEASER_H 110251881Speter