1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17
18 // SOME COMMENTS ABOUT USAGE:
19
20 // This provides primarily wp<> weak pointer types and RefBase, which work
21 // together with sp<> from <StrongPointer.h>.
22
23 // sp<> (and wp<>) are a type of smart pointer that use a well defined protocol
24 // to operate. As long as the object they are templated with implements that
25 // protocol, these smart pointers work. In several places the platform
26 // instantiates sp<> with non-RefBase objects; the two are not tied to each
27 // other.
28
29 // RefBase is such an implementation and it supports strong pointers, weak
30 // pointers and some magic features for the binder.
31
32 // So, when using RefBase objects, you have the ability to use strong and weak
33 // pointers through sp<> and wp<>.
34
35 // Normally, when the last strong pointer goes away, the object is destroyed,
36 // i.e. it's destructor is called. HOWEVER, parts of its associated memory is not
37 // freed until the last weak pointer is released.
38
39 // Weak pointers are essentially "safe" pointers. They are always safe to
40 // access through promote(). They may return nullptr if the object was
41 // destroyed because it ran out of strong pointers. This makes them good candidates
42 // for keys in a cache for instance.
43
44 // Weak pointers remain valid for comparison purposes even after the underlying
45 // object has been destroyed. Even if object A is destroyed and its memory reused
46 // for B, A remaining weak pointer to A will not compare equal to one to B.
47 // This again makes them attractive for use as keys.
48
49 // How is this supposed / intended to be used?
50
51 // Our recommendation is to use strong references (sp<>) when there is an
52 // ownership relation. e.g. when an object "owns" another one, use a strong
53 // ref. And of course use strong refs as arguments of functions (it's extremely
54 // rare that a function will take a wp<>).
55
56 // Typically a newly allocated object will immediately be used to initialize
57 // a strong pointer, which may then be used to construct or assign to other
58 // strong and weak pointers.
59
60 // Use weak references when there are no ownership relation. e.g. the keys in a
61 // cache (you cannot use plain pointers because there is no safe way to acquire
62 // a strong reference from a vanilla pointer).
63
64 // This implies that two objects should never (or very rarely) have sp<> on
65 // each other, because they can't both own each other.
66
67
68 // Caveats with reference counting
69
70 // Obviously, circular strong references are a big problem; this creates leaks
71 // and it's hard to debug -- except it's in fact really easy because RefBase has
72 // tons of debugging code for that. It can basically tell you exactly where the
73 // leak is.
74
75 // Another problem has to do with destructors with side effects. You must
76 // assume that the destructor of reference counted objects can be called AT ANY
77 // TIME. For instance code as simple as this:
78
79 // void setStuff(const sp<Stuff>& stuff) {
80 // std::lock_guard<std::mutex> lock(mMutex);
81 // mStuff = stuff;
82 // }
83
84 // is very dangerous. This code WILL deadlock one day or another.
85
86 // What isn't obvious is that ~Stuff() can be called as a result of the
87 // assignment. And it gets called with the lock held. First of all, the lock is
88 // protecting mStuff, not ~Stuff(). Secondly, if ~Stuff() uses its own internal
89 // mutex, now you have mutex ordering issues. Even worse, if ~Stuff() is
90 // virtual, now you're calling into "user" code (potentially), by that, I mean,
91 // code you didn't even write.
92
93 // A correct way to write this code is something like:
94
95 // void setStuff(const sp<Stuff>& stuff) {
96 // std::unique_lock<std::mutex> lock(mMutex);
97 // sp<Stuff> hold = mStuff;
98 // mStuff = stuff;
99 // lock.unlock();
100 // }
101
102 // More importantly, reference counted objects should do as little work as
103 // possible in their destructor, or at least be mindful that their destructor
104 // could be called from very weird and unintended places.
105
106 // Other more specific restrictions for wp<> and sp<>:
107
108 // Do not construct a strong pointer to "this" in an object's constructor.
109 // The onFirstRef() callback would be made on an incompletely constructed
110 // object.
111 // Construction of a weak pointer to "this" in an object's constructor is also
112 // discouraged. But the implementation was recently changed so that, in the
113 // absence of extendObjectLifetime() calls, weak pointers no longer impact
114 // object lifetime, and hence this no longer risks premature deallocation,
115 // and hence usually works correctly.
116
117 // Such strong or weak pointers can be safely created in the RefBase onFirstRef()
118 // callback.
119
120 // Use of wp::unsafe_get() for any purpose other than debugging is almost
121 // always wrong. Unless you somehow know that there is a longer-lived sp<> to
122 // the same object, it may well return a pointer to a deallocated object that
123 // has since been reallocated for a different purpose. (And if you know there
124 // is a longer-lived sp<>, why not use an sp<> directly?) A wp<> should only be
125 // dereferenced by using promote().
126
127 // Any object inheriting from RefBase should always be destroyed as the result
128 // of a reference count decrement, not via any other means. Such objects
129 // should never be stack allocated, or appear directly as data members in other
130 // objects. Objects inheriting from RefBase should have their strong reference
131 // count incremented as soon as possible after construction. Usually this
132 // will be done via construction of an sp<> to the object, but may instead
133 // involve other means of calling RefBase::incStrong().
134 // Explicitly deleting or otherwise destroying a RefBase object with outstanding
135 // wp<> or sp<> pointers to it will result in an abort or heap corruption.
136
137 // It is particularly important not to mix sp<> and direct storage management
138 // since the sp from raw pointer constructor is implicit. Thus if a RefBase-
139 // -derived object of type T is managed without ever incrementing its strong
140 // count, and accidentally passed to f(sp<T>), a strong pointer to the object
141 // will be temporarily constructed and destroyed, prematurely deallocating the
142 // object, and resulting in heap corruption. None of this would be easily
143 // visible in the source.
144
145 // Extra Features:
146
147 // RefBase::extendObjectLifetime() can be used to prevent destruction of the
148 // object while there are still weak references. This is really special purpose
149 // functionality to support Binder.
150
151 // Wp::promote(), implemented via the attemptIncStrong() member function, is
152 // used to try to convert a weak pointer back to a strong pointer. It's the
153 // normal way to try to access the fields of an object referenced only through
154 // a wp<>. Binder code also sometimes uses attemptIncStrong() directly.
155
156 // RefBase provides a number of additional callbacks for certain reference count
157 // events, as well as some debugging facilities.
158
159 // Debugging support can be enabled by turning on DEBUG_REFS in RefBase.cpp.
160 // Otherwise little checking is provided.
161
162 // Thread safety:
163
164 // Like std::shared_ptr, sp<> and wp<> allow concurrent accesses to DIFFERENT
165 // sp<> and wp<> instances that happen to refer to the same underlying object.
166 // They do NOT support concurrent access (where at least one access is a write)
167 // to THE SAME sp<> or wp<>. In effect, their thread-safety properties are
168 // exactly like those of T*, NOT atomic<T*>.
169
170 #ifndef ANDROID_REF_BASE_H
171 #define ANDROID_REF_BASE_H
172
173 #include <atomic>
174 #include <functional>
175 #include <type_traits> // for common_type.
176
177 #include <stdint.h>
178 #include <sys/types.h>
179 #include <stdlib.h>
180 #include <string.h>
181
182 // LightRefBase used to be declared in this header, so we have to include it
183 #include <utils/LightRefBase.h>
184
185 #include <utils/StrongPointer.h>
186 #include <utils/TypeHelpers.h>
187
188 // ---------------------------------------------------------------------------
189 namespace android {
190
191 class TextOutput;
192 TextOutput& printWeakPointer(TextOutput& to, const void* val);
193
194 // ---------------------------------------------------------------------------
195
196 #define COMPARE_WEAK(_op_) \
197 template<typename U> \
198 inline bool operator _op_ (const U* o) const { \
199 return m_ptr _op_ o; \
200 } \
201 /* Needed to handle type inference for nullptr: */ \
202 inline bool operator _op_ (const T* o) const { \
203 return m_ptr _op_ o; \
204 }
205
206 template<template<typename C> class comparator, typename T, typename U>
_wp_compare_(T * a,U * b)207 static inline bool _wp_compare_(T* a, U* b) {
208 return comparator<typename std::common_type<T*, U*>::type>()(a, b);
209 }
210
211 // Use std::less and friends to avoid undefined behavior when ordering pointers
212 // to different objects.
213 #define COMPARE_WEAK_FUNCTIONAL(_op_, _compare_) \
214 template<typename U> \
215 inline bool operator _op_ (const U* o) const { \
216 return _wp_compare_<_compare_>(m_ptr, o); \
217 }
218
219 // ---------------------------------------------------------------------------
220
221 // RefererenceRenamer is pure abstract, there is no virtual method
222 // implementation to put in a translation unit in order to silence the
223 // weak vtables warning.
224 #if defined(__clang__)
225 #pragma clang diagnostic push
226 #pragma clang diagnostic ignored "-Wweak-vtables"
227 #endif
228
229 class ReferenceRenamer {
230 protected:
231 // destructor is purposely not virtual so we avoid code overhead from
232 // subclasses; we have to make it protected to guarantee that it
233 // cannot be called from this base class (and to make strict compilers
234 // happy).
~ReferenceRenamer()235 ~ReferenceRenamer() { }
236 public:
237 virtual void operator()(size_t i) const = 0;
238 };
239
240 #if defined(__clang__)
241 #pragma clang diagnostic pop
242 #endif
243
244 // ---------------------------------------------------------------------------
245
246 class RefBase
247 {
248 public:
249 void incStrong(const void* id) const;
250 void decStrong(const void* id) const;
251
252 void forceIncStrong(const void* id) const;
253
254 //! DEBUGGING ONLY: Get current strong ref count.
255 int32_t getStrongCount() const;
256
257 class weakref_type
258 {
259 public:
260 RefBase* refBase() const;
261
262 void incWeak(const void* id);
263 void decWeak(const void* id);
264
265 // acquires a strong reference if there is already one.
266 bool attemptIncStrong(const void* id);
267
268 // acquires a weak reference if there is already one.
269 // This is not always safe. see ProcessState.cpp and BpBinder.cpp
270 // for proper use.
271 bool attemptIncWeak(const void* id);
272
273 //! DEBUGGING ONLY: Get current weak ref count.
274 int32_t getWeakCount() const;
275
276 //! DEBUGGING ONLY: Print references held on object.
277 void printRefs() const;
278
279 //! DEBUGGING ONLY: Enable tracking for this object.
280 // enable -- enable/disable tracking
281 // retain -- when tracking is enable, if true, then we save a stack trace
282 // for each reference and dereference; when retain == false, we
283 // match up references and dereferences and keep only the
284 // outstanding ones.
285
286 void trackMe(bool enable, bool retain);
287 };
288
289 weakref_type* createWeak(const void* id) const;
290
291 weakref_type* getWeakRefs() const;
292
293 //! DEBUGGING ONLY: Print references held on object.
printRefs()294 inline void printRefs() const { getWeakRefs()->printRefs(); }
295
296 //! DEBUGGING ONLY: Enable tracking of object.
trackMe(bool enable,bool retain)297 inline void trackMe(bool enable, bool retain)
298 {
299 getWeakRefs()->trackMe(enable, retain);
300 }
301
302 typedef RefBase basetype;
303
304 protected:
305 RefBase();
306 virtual ~RefBase();
307
308 //! Flags for extendObjectLifetime()
309 enum {
310 OBJECT_LIFETIME_STRONG = 0x0000,
311 OBJECT_LIFETIME_WEAK = 0x0001,
312 OBJECT_LIFETIME_MASK = 0x0001
313 };
314
315 void extendObjectLifetime(int32_t mode);
316
317 //! Flags for onIncStrongAttempted()
318 enum {
319 FIRST_INC_STRONG = 0x0001
320 };
321
322 // Invoked after creation of initial strong pointer/reference.
323 virtual void onFirstRef();
324 // Invoked when either the last strong reference goes away, or we need to undo
325 // the effect of an unnecessary onIncStrongAttempted.
326 virtual void onLastStrongRef(const void* id);
327 // Only called in OBJECT_LIFETIME_WEAK case. Returns true if OK to promote to
328 // strong reference. May have side effects if it returns true.
329 // The first flags argument is always FIRST_INC_STRONG.
330 // TODO: Remove initial flag argument.
331 virtual bool onIncStrongAttempted(uint32_t flags, const void* id);
332 // Invoked in the OBJECT_LIFETIME_WEAK case when the last reference of either
333 // kind goes away. Unused.
334 // TODO: Remove.
335 virtual void onLastWeakRef(const void* id);
336
337 private:
338 friend class weakref_type;
339 class weakref_impl;
340
341 RefBase(const RefBase& o);
342 RefBase& operator=(const RefBase& o);
343
344 private:
345 friend class ReferenceMover;
346
347 static void renameRefs(size_t n, const ReferenceRenamer& renamer);
348
349 static void renameRefId(weakref_type* ref,
350 const void* old_id, const void* new_id);
351
352 static void renameRefId(RefBase* ref,
353 const void* old_id, const void* new_id);
354
355 weakref_impl* const mRefs;
356 };
357
358 // ---------------------------------------------------------------------------
359
360 template <typename T>
361 class wp
362 {
363 public:
364 typedef typename RefBase::weakref_type weakref_type;
365
wp()366 inline wp() : m_ptr(nullptr), m_refs(nullptr) { }
367
368 wp(T* other); // NOLINT(implicit)
369 wp(const wp<T>& other);
370 explicit wp(const sp<T>& other);
371 template<typename U> wp(U* other); // NOLINT(implicit)
372 template<typename U> wp(const sp<U>& other); // NOLINT(implicit)
373 template<typename U> wp(const wp<U>& other); // NOLINT(implicit)
374
375 ~wp();
376
377 // Assignment
378
379 wp& operator = (T* other);
380 wp& operator = (const wp<T>& other);
381 wp& operator = (const sp<T>& other);
382
383 template<typename U> wp& operator = (U* other);
384 template<typename U> wp& operator = (const wp<U>& other);
385 template<typename U> wp& operator = (const sp<U>& other);
386
387 void set_object_and_refs(T* other, weakref_type* refs);
388
389 // promotion to sp
390
391 sp<T> promote() const;
392
393 // Reset
394
395 void clear();
396
397 // Accessors
398
get_refs()399 inline weakref_type* get_refs() const { return m_refs; }
400
unsafe_get()401 inline T* unsafe_get() const { return m_ptr; }
402
403 // Operators
404
405 COMPARE_WEAK(==)
406 COMPARE_WEAK(!=)
407 COMPARE_WEAK_FUNCTIONAL(>, std::greater)
408 COMPARE_WEAK_FUNCTIONAL(<, std::less)
409 COMPARE_WEAK_FUNCTIONAL(<=, std::less_equal)
410 COMPARE_WEAK_FUNCTIONAL(>=, std::greater_equal)
411
412 template<typename U>
413 inline bool operator == (const wp<U>& o) const {
414 return m_refs == o.m_refs; // Implies m_ptr == o.mptr; see invariants below.
415 }
416
417 template<typename U>
418 inline bool operator == (const sp<U>& o) const {
419 // Just comparing m_ptr fields is often dangerous, since wp<> may refer to an older
420 // object at the same address.
421 if (o == nullptr) {
422 return m_ptr == nullptr;
423 } else {
424 return m_refs == o->getWeakRefs(); // Implies m_ptr == o.mptr.
425 }
426 }
427
428 template<typename U>
429 inline bool operator != (const sp<U>& o) const {
430 return !(*this == o);
431 }
432
433 template<typename U>
434 inline bool operator > (const wp<U>& o) const {
435 if (m_ptr == o.m_ptr) {
436 return _wp_compare_<std::greater>(m_refs, o.m_refs);
437 } else {
438 return _wp_compare_<std::greater>(m_ptr, o.m_ptr);
439 }
440 }
441
442 template<typename U>
443 inline bool operator < (const wp<U>& o) const {
444 if (m_ptr == o.m_ptr) {
445 return _wp_compare_<std::less>(m_refs, o.m_refs);
446 } else {
447 return _wp_compare_<std::less>(m_ptr, o.m_ptr);
448 }
449 }
450 template<typename U> inline bool operator != (const wp<U>& o) const { return !operator == (o); }
451 template<typename U> inline bool operator <= (const wp<U>& o) const { return !operator > (o); }
452 template<typename U> inline bool operator >= (const wp<U>& o) const { return !operator < (o); }
453
454 private:
455 template<typename Y> friend class sp;
456 template<typename Y> friend class wp;
457
458 T* m_ptr;
459 weakref_type* m_refs;
460 };
461
462 template <typename T>
463 TextOutput& operator<<(TextOutput& to, const wp<T>& val);
464
465 #undef COMPARE_WEAK
466
467 // ---------------------------------------------------------------------------
468 // No user serviceable parts below here.
469
470 // Implementation invariants:
471 // Either
472 // 1) m_ptr and m_refs are both null, or
473 // 2) m_refs == m_ptr->mRefs, or
474 // 3) *m_ptr is no longer live, and m_refs points to the weakref_type object that corresponded
475 // to m_ptr while it was live. *m_refs remains live while a wp<> refers to it.
476 //
477 // The m_refs field in a RefBase object is allocated on construction, unique to that RefBase
478 // object, and never changes. Thus if two wp's have identical m_refs fields, they are either both
479 // null or point to the same object. If two wp's have identical m_ptr fields, they either both
480 // point to the same live object and thus have the same m_ref fields, or at least one of the
481 // objects is no longer live.
482 //
483 // Note that the above comparison operations go out of their way to provide an ordering consistent
484 // with ordinary pointer comparison; otherwise they could ignore m_ptr, and just compare m_refs.
485
486 template<typename T>
wp(T * other)487 wp<T>::wp(T* other)
488 : m_ptr(other)
489 {
490 m_refs = other ? m_refs = other->createWeak(this) : nullptr;
491 }
492
493 template<typename T>
wp(const wp<T> & other)494 wp<T>::wp(const wp<T>& other)
495 : m_ptr(other.m_ptr), m_refs(other.m_refs)
496 {
497 if (m_ptr) m_refs->incWeak(this);
498 }
499
500 template<typename T>
wp(const sp<T> & other)501 wp<T>::wp(const sp<T>& other)
502 : m_ptr(other.m_ptr)
503 {
504 m_refs = m_ptr ? m_ptr->createWeak(this) : nullptr;
505 }
506
507 template<typename T> template<typename U>
wp(U * other)508 wp<T>::wp(U* other)
509 : m_ptr(other)
510 {
511 m_refs = other ? other->createWeak(this) : nullptr;
512 }
513
514 template<typename T> template<typename U>
wp(const wp<U> & other)515 wp<T>::wp(const wp<U>& other)
516 : m_ptr(other.m_ptr)
517 {
518 if (m_ptr) {
519 m_refs = other.m_refs;
520 m_refs->incWeak(this);
521 } else {
522 m_refs = nullptr;
523 }
524 }
525
526 template<typename T> template<typename U>
wp(const sp<U> & other)527 wp<T>::wp(const sp<U>& other)
528 : m_ptr(other.m_ptr)
529 {
530 m_refs = m_ptr ? m_ptr->createWeak(this) : nullptr;
531 }
532
533 template<typename T>
~wp()534 wp<T>::~wp()
535 {
536 if (m_ptr) m_refs->decWeak(this);
537 }
538
539 template<typename T>
540 wp<T>& wp<T>::operator = (T* other)
541 {
542 weakref_type* newRefs =
543 other ? other->createWeak(this) : nullptr;
544 if (m_ptr) m_refs->decWeak(this);
545 m_ptr = other;
546 m_refs = newRefs;
547 return *this;
548 }
549
550 template<typename T>
551 wp<T>& wp<T>::operator = (const wp<T>& other)
552 {
553 weakref_type* otherRefs(other.m_refs);
554 T* otherPtr(other.m_ptr);
555 if (otherPtr) otherRefs->incWeak(this);
556 if (m_ptr) m_refs->decWeak(this);
557 m_ptr = otherPtr;
558 m_refs = otherRefs;
559 return *this;
560 }
561
562 template<typename T>
563 wp<T>& wp<T>::operator = (const sp<T>& other)
564 {
565 weakref_type* newRefs =
566 other != nullptr ? other->createWeak(this) : nullptr;
567 T* otherPtr(other.m_ptr);
568 if (m_ptr) m_refs->decWeak(this);
569 m_ptr = otherPtr;
570 m_refs = newRefs;
571 return *this;
572 }
573
574 template<typename T> template<typename U>
575 wp<T>& wp<T>::operator = (U* other)
576 {
577 weakref_type* newRefs =
578 other ? other->createWeak(this) : 0;
579 if (m_ptr) m_refs->decWeak(this);
580 m_ptr = other;
581 m_refs = newRefs;
582 return *this;
583 }
584
585 template<typename T> template<typename U>
586 wp<T>& wp<T>::operator = (const wp<U>& other)
587 {
588 weakref_type* otherRefs(other.m_refs);
589 U* otherPtr(other.m_ptr);
590 if (otherPtr) otherRefs->incWeak(this);
591 if (m_ptr) m_refs->decWeak(this);
592 m_ptr = otherPtr;
593 m_refs = otherRefs;
594 return *this;
595 }
596
597 template<typename T> template<typename U>
598 wp<T>& wp<T>::operator = (const sp<U>& other)
599 {
600 weakref_type* newRefs =
601 other != nullptr ? other->createWeak(this) : 0;
602 U* otherPtr(other.m_ptr);
603 if (m_ptr) m_refs->decWeak(this);
604 m_ptr = otherPtr;
605 m_refs = newRefs;
606 return *this;
607 }
608
609 template<typename T>
set_object_and_refs(T * other,weakref_type * refs)610 void wp<T>::set_object_and_refs(T* other, weakref_type* refs)
611 {
612 if (other) refs->incWeak(this);
613 if (m_ptr) m_refs->decWeak(this);
614 m_ptr = other;
615 m_refs = refs;
616 }
617
618 template<typename T>
promote()619 sp<T> wp<T>::promote() const
620 {
621 sp<T> result;
622 if (m_ptr && m_refs->attemptIncStrong(&result)) {
623 result.set_pointer(m_ptr);
624 }
625 return result;
626 }
627
628 template<typename T>
clear()629 void wp<T>::clear()
630 {
631 if (m_ptr) {
632 m_refs->decWeak(this);
633 m_refs = 0;
634 m_ptr = 0;
635 }
636 }
637
638 template <typename T>
639 inline TextOutput& operator<<(TextOutput& to, const wp<T>& val)
640 {
641 return printWeakPointer(to, val.unsafe_get());
642 }
643
644 // ---------------------------------------------------------------------------
645
646 // this class just serves as a namespace so TYPE::moveReferences can stay
647 // private.
648 class ReferenceMover {
649 public:
650 // it would be nice if we could make sure no extra code is generated
651 // for sp<TYPE> or wp<TYPE> when TYPE is a descendant of RefBase:
652 // Using a sp<RefBase> override doesn't work; it's a bit like we wanted
653 // a template<typename TYPE inherits RefBase> template...
654
655 template<typename TYPE> static inline
move_references(sp<TYPE> * dest,sp<TYPE> const * src,size_t n)656 void move_references(sp<TYPE>* dest, sp<TYPE> const* src, size_t n) {
657
658 class Renamer : public ReferenceRenamer {
659 sp<TYPE>* d_;
660 sp<TYPE> const* s_;
661 virtual void operator()(size_t i) const {
662 // The id are known to be the sp<>'s this pointer
663 TYPE::renameRefId(d_[i].get(), &s_[i], &d_[i]);
664 }
665 public:
666 Renamer(sp<TYPE>* d, sp<TYPE> const* s) : d_(d), s_(s) { }
667 virtual ~Renamer() { }
668 };
669
670 memmove(dest, src, n*sizeof(sp<TYPE>));
671 TYPE::renameRefs(n, Renamer(dest, src));
672 }
673
674
675 template<typename TYPE> static inline
move_references(wp<TYPE> * dest,wp<TYPE> const * src,size_t n)676 void move_references(wp<TYPE>* dest, wp<TYPE> const* src, size_t n) {
677
678 class Renamer : public ReferenceRenamer {
679 wp<TYPE>* d_;
680 wp<TYPE> const* s_;
681 virtual void operator()(size_t i) const {
682 // The id are known to be the wp<>'s this pointer
683 TYPE::renameRefId(d_[i].get_refs(), &s_[i], &d_[i]);
684 }
685 public:
686 Renamer(wp<TYPE>* rd, wp<TYPE> const* rs) : d_(rd), s_(rs) { }
687 virtual ~Renamer() { }
688 };
689
690 memmove(dest, src, n*sizeof(wp<TYPE>));
691 TYPE::renameRefs(n, Renamer(dest, src));
692 }
693 };
694
695 // specialization for moving sp<> and wp<> types.
696 // these are used by the [Sorted|Keyed]Vector<> implementations
697 // sp<> and wp<> need to be handled specially, because they do not
698 // have trivial copy operation in the general case (see RefBase.cpp
699 // when DEBUG ops are enabled), but can be implemented very
700 // efficiently in most cases.
701
702 template<typename TYPE> inline
move_forward_type(sp<TYPE> * d,sp<TYPE> const * s,size_t n)703 void move_forward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
704 ReferenceMover::move_references(d, s, n);
705 }
706
707 template<typename TYPE> inline
move_backward_type(sp<TYPE> * d,sp<TYPE> const * s,size_t n)708 void move_backward_type(sp<TYPE>* d, sp<TYPE> const* s, size_t n) {
709 ReferenceMover::move_references(d, s, n);
710 }
711
712 template<typename TYPE> inline
move_forward_type(wp<TYPE> * d,wp<TYPE> const * s,size_t n)713 void move_forward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
714 ReferenceMover::move_references(d, s, n);
715 }
716
717 template<typename TYPE> inline
move_backward_type(wp<TYPE> * d,wp<TYPE> const * s,size_t n)718 void move_backward_type(wp<TYPE>* d, wp<TYPE> const* s, size_t n) {
719 ReferenceMover::move_references(d, s, n);
720 }
721
722 } // namespace android
723
724 // ---------------------------------------------------------------------------
725
726 #endif // ANDROID_REF_BASE_H
727