1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef BASE_MEMORY_SCOPED_NSOBJECT_H_ 6 #define BASE_MEMORY_SCOPED_NSOBJECT_H_ 7 #pragma once 8 9 #import <Foundation/Foundation.h> 10 #include "base/basictypes.h" 11 #include "base/compiler_specific.h" 12 13 // scoped_nsobject<> is patterned after scoped_ptr<>, but maintains ownership 14 // of an NSObject subclass object. Style deviations here are solely for 15 // compatibility with scoped_ptr<>'s interface, with which everyone is already 16 // familiar. 17 // 18 // When scoped_nsobject<> takes ownership of an object (in the constructor or 19 // in reset()), it takes over the caller's existing ownership claim. The 20 // caller must own the object it gives to scoped_nsobject<>, and relinquishes 21 // an ownership claim to that object. scoped_nsobject<> does not call 22 // -retain. 23 // 24 // scoped_nsobject<> is not to be used for NSAutoreleasePools. For 25 // NSAutoreleasePools use ScopedNSAutoreleasePool from 26 // scoped_nsautorelease_pool.h instead. 27 // We check for bad uses of scoped_nsobject and NSAutoreleasePool at compile 28 // time with a template specialization (see below). 29 template<typename NST> 30 class scoped_nsobject { 31 public: 32 typedef NST* element_type; 33 34 explicit scoped_nsobject(NST* object = nil) 35 : object_(object) { 36 } 37 38 ~scoped_nsobject() { 39 [object_ release]; 40 } 41 42 void reset(NST* object = nil) { 43 // We intentionally do not check that object != object_ as the caller must 44 // already have an ownership claim over whatever it gives to 45 // scoped_nsobject and ScopedCFTypeRef, whether it's in the constructor or 46 // in a call to reset(). In either case, it relinquishes that claim and 47 // the scoper assumes it. 48 [object_ release]; 49 object_ = object; 50 } 51 52 bool operator==(NST* that) const { return object_ == that; } 53 bool operator!=(NST* that) const { return object_ != that; } 54 55 operator NST*() const { 56 return object_; 57 } 58 59 NST* get() const { 60 return object_; 61 } 62 63 void swap(scoped_nsobject& that) { 64 NST* temp = that.object_; 65 that.object_ = object_; 66 object_ = temp; 67 } 68 69 // scoped_nsobject<>::release() is like scoped_ptr<>::release. It is NOT 70 // a wrapper for [object_ release]. To force a scoped_nsobject<> object to 71 // call [object_ release], use scoped_nsobject<>::reset(). 72 NST* release() WARN_UNUSED_RESULT { 73 NST* temp = object_; 74 object_ = nil; 75 return temp; 76 } 77 78 private: 79 NST* object_; 80 81 DISALLOW_COPY_AND_ASSIGN(scoped_nsobject); 82 }; 83 84 // Free functions 85 template <class C> 86 void swap(scoped_nsobject<C>& p1, scoped_nsobject<C>& p2) { 87 p1.swap(p2); 88 } 89 90 template <class C> 91 bool operator==(C* p1, const scoped_nsobject<C>& p2) { 92 return p1 == p2.get(); 93 } 94 95 template <class C> 96 bool operator!=(C* p1, const scoped_nsobject<C>& p2) { 97 return p1 != p2.get(); 98 } 99 100 101 // Specialization to make scoped_nsobject<id> work. 102 template<> 103 class scoped_nsobject<id> { 104 public: 105 typedef id element_type; 106 107 explicit scoped_nsobject(id object = nil) 108 : object_(object) { 109 } 110 111 ~scoped_nsobject() { 112 [object_ release]; 113 } 114 115 void reset(id object = nil) { 116 // We intentionally do not check that object != object_ as the caller must 117 // already have an ownership claim over whatever it gives to 118 // scoped_nsobject and ScopedCFTypeRef, whether it's in the constructor or 119 // in a call to reset(). In either case, it relinquishes that claim and 120 // the scoper assumes it. 121 [object_ release]; 122 object_ = object; 123 } 124 125 bool operator==(id that) const { return object_ == that; } 126 bool operator!=(id that) const { return object_ != that; } 127 128 operator id() const { 129 return object_; 130 } 131 132 id get() const { 133 return object_; 134 } 135 136 void swap(scoped_nsobject& that) { 137 id temp = that.object_; 138 that.object_ = object_; 139 object_ = temp; 140 } 141 142 // scoped_nsobject<>::release() is like scoped_ptr<>::release. It is NOT 143 // a wrapper for [object_ release]. To force a scoped_nsobject<> object to 144 // call [object_ release], use scoped_nsobject<>::reset(). 145 id release() WARN_UNUSED_RESULT { 146 id temp = object_; 147 object_ = nil; 148 return temp; 149 } 150 151 private: 152 id object_; 153 154 DISALLOW_COPY_AND_ASSIGN(scoped_nsobject); 155 }; 156 157 // Do not use scoped_nsobject for NSAutoreleasePools, use 158 // ScopedNSAutoreleasePool instead. This is a compile time check. See details 159 // at top of header. 160 template<> 161 class scoped_nsobject<NSAutoreleasePool> { 162 private: 163 explicit scoped_nsobject(NSAutoreleasePool* object = nil); 164 DISALLOW_COPY_AND_ASSIGN(scoped_nsobject); 165 }; 166 167 #endif // BASE_MEMORY_SCOPED_NSOBJECT_H_ 168