]>
git.saurik.com Git - apple/security.git/blob - Security/libsecurity_utilities/lib/refcount.h
2 * Copyright (c) 2000-2004,2011-2014 Apple Inc. All Rights Reserved.
4 * @APPLE_LICENSE_HEADER_START@
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
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.
21 * @APPLE_LICENSE_HEADER_END@
27 #ifndef _SECURITY_REFCOUNT_H_
28 #define _SECURITY_REFCOUNT_H_
30 #include <security_utilities/threading.h>
31 #include <libkern/OSAtomic.h>
37 // RefCount/RefPointer - a simple reference counting facility.
39 // To make an object reference-counted, inherit from RefCount. To track refcounted
40 // objects, use RefPointer<TheType>, where TheType must inherit from RefCount.
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.
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.
52 #if !defined(DEBUG_REFCOUNTS)
53 # define DEBUG_REFCOUNTS 1
57 # define RCDEBUG(_kind, _args...) SECURITY_DEBUG_REFCOUNT_##_kind((void *)this, ##_args)
59 # define RCDEBUG(kind) /* nothing */
64 // Base class for reference counted objects
68 RefCount() : mRefCount(0) { RCDEBUG(CREATE
); }
71 template <class T
> friend class RefPointer
;
75 OSAtomicIncrement32(&mRefCount
);
76 RCDEBUG(UP
, mRefCount
);
79 unsigned int unref() const
81 RCDEBUG(DOWN
, mRefCount
- 1);
82 return OSAtomicDecrement32(&mRefCount
);
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
; }
89 volatile mutable int32_t mRefCount
;
94 // A pointer type supported by reference counts.
95 // T must be derived from RefCount.
99 template <class Sub
> friend class RefPointer
; // share with other instances
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
; }
106 RefPointer(const RefPointer
<Sub
>& p
) { if (p
) p
->ref(); ptr
= p
.ptr
; }
108 ~RefPointer() { release(); }
110 RefPointer
& operator = (const RefPointer
& p
) { setPointer(p
.ptr
); return *this; }
111 RefPointer
& operator = (T
* p
) { setPointer(p
); return *this; }
114 RefPointer
& operator = (const RefPointer
<Sub
>& p
) { setPointer(p
.ptr
); return *this; }
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
; }
123 void release_internal()
125 if (ptr
&& ptr
->unref() == 0)
134 StLock
<Mutex
> mutexLock(mMutex
);
138 void setPointer(T
*p
)
140 StLock
<Mutex
> mutexLock(mMutex
);
150 void _check() const { }
157 bool operator <(const RefPointer
<T
> &r1
, const RefPointer
<T
> &r2
)
159 T
*p1
= r1
.get(), *p2
= r2
.get();
160 return p1
&& p2
? *p1
< *p2
: p1
< p2
;
164 bool operator ==(const RefPointer
<T
> &r1
, const RefPointer
<T
> &r2
)
166 T
*p1
= r1
.get(), *p2
= r2
.get();
167 return p1
&& p2
? *p1
== *p2
: p1
== p2
;
171 bool operator !=(const RefPointer
<T
> &r1
, const RefPointer
<T
> &r2
)
173 T
*p1
= r1
.get(), *p2
= r2
.get();
174 return p1
&& p2
? *p1
!= *p2
: p1
!= p2
;
177 } // end namespace Security
179 #endif // !_SECURITY_REFCOUNT_H_