1/* 2 * Copyright (c) 2000-2004,2011-2014 Apple Inc. All Rights Reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. Please obtain a copy of the License at 10 * http://www.opensource.apple.com/apsl/ and read it before using this 11 * file. 12 * 13 * The Original Code and all software distributed under the License are 14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 18 * Please see the License for the specific language governing rights and 19 * limitations under the License. 20 * 21 * @APPLE_LICENSE_HEADER_END@ 22 */ 23 24 25/* 26 */ 27#ifndef _SECURITY_REFCOUNT_H_ 28#define _SECURITY_REFCOUNT_H_ 29 30#include <security_utilities/threading.h> 31#include <libkern/OSAtomic.h> 32 33namespace Security { 34 35 36// 37// RefCount/RefPointer - a simple reference counting facility. 38// 39// To make an object reference-counted, inherit from RefCount. To track refcounted 40// objects, use RefPointer<TheType>, where TheType must inherit from RefCount. 41// 42// RefCount is thread safe - any number of threads can hold and manipulate references 43// in parallel. It does however NOT protect the contents of your object - just the 44// reference count itself. If you need to share your object contents, you must provide 45// appropriate locking yourself. 46// 47// There is no (thread safe) way to determine whether you are the only thread holding 48// a pointer to a particular RefCount object. Thus there is no (thread safe) 49// way to "demand copy" a RefCount subclass. Trust me; it's been tried. Don't. 50// 51 52#if !defined(DEBUG_REFCOUNTS) 53# define DEBUG_REFCOUNTS 1 54#endif 55 56#if DEBUG_REFCOUNTS 57# define RCDEBUG(_kind, _args...) SECURITY_DEBUG_REFCOUNT_##_kind((void *)this, ##_args) 58#else 59# define RCDEBUG(kind) /* nothing */ 60#endif 61 62 63// 64// Base class for reference counted objects 65// 66class RefCount { 67public: 68 RefCount() : mRefCount(0) { RCDEBUG(CREATE); } 69 70protected: 71 template <class T> friend class RefPointer; 72 73 void ref() const 74 { 75 OSAtomicIncrement32(&mRefCount); 76 RCDEBUG(UP, mRefCount); 77 } 78 79 unsigned int unref() const 80 { 81 RCDEBUG(DOWN, mRefCount - 1); 82 return OSAtomicDecrement32(&mRefCount); 83 } 84 85 // if you call this for anything but debug output, you will go to hell (free handbasket included) 86 unsigned int refCountForDebuggingOnly() const { return mRefCount; } 87 88private: 89 volatile mutable int32_t mRefCount; 90}; 91 92 93// 94// A pointer type supported by reference counts. 95// T must be derived from RefCount. 96// 97template <class T> 98class RefPointer { 99 template <class Sub> friend class RefPointer; // share with other instances 100public: 101 RefPointer() : ptr(0) {} // default to NULL pointer 102 RefPointer(const RefPointer& p) { if (p) p->ref(); ptr = p.ptr; } 103 RefPointer(T *p) { if (p) p->ref(); ptr = p; } 104 105 template <class Sub> 106 RefPointer(const RefPointer<Sub>& p) { if (p) p->ref(); ptr = p.ptr; } 107 108 ~RefPointer() { release(); } 109 110 RefPointer& operator = (const RefPointer& p) { setPointer(p.ptr); return *this; } 111 RefPointer& operator = (T * p) { setPointer(p); return *this; } 112 113 template <class Sub> 114 RefPointer& operator = (const RefPointer<Sub>& p) { setPointer(p.ptr); return *this; } 115 116 // dereference operations 117 T* get () const { _check(); return ptr; } // mimic auto_ptr 118 operator T * () const { _check(); return ptr; } 119 T * operator -> () const { _check(); return ptr; } 120 T & operator * () const { _check(); return *ptr; } 121 122protected: 123 void release_internal() 124 { 125 if (ptr && ptr->unref() == 0) 126 { 127 delete ptr; 128 ptr = NULL; 129 } 130 } 131 132 void release() 133 { 134 StLock<Mutex> mutexLock(mMutex); 135 release_internal(); 136 } 137 138 void setPointer(T *p) 139 { 140 StLock<Mutex> mutexLock(mMutex); 141 if (p) 142 { 143 p->ref(); 144 } 145 146 release_internal(); 147 ptr = p; 148 } 149 150 void _check() const { } 151 152 T *ptr; 153 Mutex mMutex; 154}; 155 156template <class T> 157bool operator <(const RefPointer<T> &r1, const RefPointer<T> &r2) 158{ 159 T *p1 = r1.get(), *p2 = r2.get(); 160 return p1 && p2 ? *p1 < *p2 : p1 < p2; 161} 162 163template <class T> 164bool operator ==(const RefPointer<T> &r1, const RefPointer<T> &r2) 165{ 166 T *p1 = r1.get(), *p2 = r2.get(); 167 return p1 && p2 ? *p1 == *p2 : p1 == p2; 168} 169 170template <class T> 171bool operator !=(const RefPointer<T> &r1, const RefPointer<T> &r2) 172{ 173 T *p1 = r1.get(), *p2 = r2.get(); 174 return p1 && p2 ? *p1 != *p2 : p1 != p2; 175} 176 177} // end namespace Security 178 179#endif // !_SECURITY_REFCOUNT_H_ 180