Searched defs:linked_ptr (Results 1 - 11 of 11) sorted by relevance

/external/chromium_org/third_party/webrtc/base/
H A Dlinked_ptr.h12 * linked_ptr - simple reference linked pointer
16 * The implementation stores three pointers for every linked_ptr, but
29 template <class X> class linked_ptr class in namespace:rtc
35 TEMPLATE_FUNCTION friend class linked_ptr<Y>;
43 explicit linked_ptr(X* p = 0) throw() function in class:rtc::linked_ptr
45 ~linked_ptr()
47 linked_ptr(const linked_ptr& r) throw() function in class:rtc::linked_ptr
49 linked_ptr& operator=(const linked_ptr
60 template <class Y> linked_ptr(const linked_ptr<Y>& r) throw() function in class:rtc::linked_ptr
[all...]
/external/chromium_org/base/memory/
H A Dlinked_ptr.h16 // - References are only tracked as long as linked_ptr<> objects are copied.
17 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
21 // You can safely put linked_ptr<> in a vector<>.
24 // Note: If you use an incomplete type with linked_ptr<>, the class
25 // *containing* linked_ptr<> must have a constructor and destructor (even
29 // A linked_ptr is NOT thread safe. Copying a linked_ptr object is
32 // Alternative: to linked_ptr is shared_ptr, which
42 // This is used internally by all instances of linked_ptr<>. It needs to be
43 // a non-template class because different types of linked_ptr<> ca
77 class linked_ptr { class
83 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:linked_ptr
87 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:linked_ptr
89 linked_ptr(linked_ptr const& ptr) { function in class:linked_ptr
[all...]
/external/chromium_org/media/cdm/ppapi/
H A Dlinked_ptr.h5 // This is a copy of base/linked_ptr.h with CHECKS/DCHECKS replaced with
19 // - References are only tracked as long as linked_ptr<> objects are copied.
20 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
24 // You can safely put linked_ptr<> in a vector<>.
27 // Note: If you use an incomplete type with linked_ptr<>, the class
28 // *containing* linked_ptr<> must have a constructor and destructor (even
32 // A linked_ptr is NOT thread safe. Copying a linked_ptr object is
35 // Alternative: to linked_ptr is shared_ptr, which
45 // This is used internally by all instances of linked_ptr<>
80 class linked_ptr { class
86 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:linked_ptr
90 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:linked_ptr
92 linked_ptr(linked_ptr const& ptr) { function in class:linked_ptr
[all...]
/external/chromium_org/testing/gtest/include/gtest/internal/
H A Dgtest-linked_ptr.h43 // - References are only tracked as long as linked_ptr<> objects are copied.
44 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
48 // You can safely put linked_ptr<> in a vector<>.
51 // Note: If you use an incomplete type with linked_ptr<>, the class
52 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // Unlike other linked_ptr implementations, in this implementation
59 // a linked_ptr object is thread-safe in the sense that:
60 // - it's safe to copy linked_ptr objects concurrently,
61 // - it's safe to copy *from* a linked_ptr and read its underlying
66 // confusion with normal linked_ptr
136 class linked_ptr { class in namespace:testing::internal
142 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
146 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
147 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/chromium_org/third_party/mesa/src/src/gtest/include/gtest/internal/
H A Dgtest-linked_ptr.h43 // - References are only tracked as long as linked_ptr<> objects are copied.
44 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
48 // You can safely put linked_ptr<> in a vector<>.
51 // Note: If you use an incomplete type with linked_ptr<>, the class
52 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // Unlike other linked_ptr implementations, in this implementation
59 // a linked_ptr object is thread-safe in the sense that:
60 // - it's safe to copy linked_ptr objects concurrently,
61 // - it's safe to copy *from* a linked_ptr and read its underlying
66 // confusion with normal linked_ptr
136 class linked_ptr { class in namespace:testing::internal
142 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
146 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
147 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/gtest/include/gtest/internal/
H A Dgtest-linked_ptr.h43 // - References are only tracked as long as linked_ptr<> objects are copied.
44 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
48 // You can safely put linked_ptr<> in a vector<>.
51 // Note: If you use an incomplete type with linked_ptr<>, the class
52 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // Unlike other linked_ptr implementations, in this implementation
59 // a linked_ptr object is thread-safe in the sense that:
60 // - it's safe to copy linked_ptr objects concurrently,
61 // - it's safe to copy *from* a linked_ptr and read its underlying
66 // confusion with normal linked_ptr
136 class linked_ptr { class in namespace:testing::internal
142 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
146 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
147 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/llvm/utils/unittest/googletest/include/gtest/internal/
H A Dgtest-linked_ptr.h43 // - References are only tracked as long as linked_ptr<> objects are copied.
44 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
48 // You can safely put linked_ptr<> in a vector<>.
51 // Note: If you use an incomplete type with linked_ptr<>, the class
52 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // Unlike other linked_ptr implementations, in this implementation
59 // a linked_ptr object is thread-safe in the sense that:
60 // - it's safe to copy linked_ptr objects concurrently,
61 // - it's safe to copy *from* a linked_ptr and read its underlying
66 // confusion with normal linked_ptr
136 class linked_ptr { class in namespace:testing::internal
142 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
146 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
147 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/mesa3d/src/gtest/include/gtest/internal/
H A Dgtest-linked_ptr.h43 // - References are only tracked as long as linked_ptr<> objects are copied.
44 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
48 // You can safely put linked_ptr<> in a vector<>.
51 // Note: If you use an incomplete type with linked_ptr<>, the class
52 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // Unlike other linked_ptr implementations, in this implementation
59 // a linked_ptr object is thread-safe in the sense that:
60 // - it's safe to copy linked_ptr objects concurrently,
61 // - it's safe to copy *from* a linked_ptr and read its underlying
66 // confusion with normal linked_ptr
136 class linked_ptr { class in namespace:testing::internal
142 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
146 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
147 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/protobuf/gtest/include/gtest/internal/
H A Dgtest-linked_ptr.h43 // - References are only tracked as long as linked_ptr<> objects are copied.
44 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
48 // You can safely put linked_ptr<> in a vector<>.
51 // Note: If you use an incomplete type with linked_ptr<>, the class
52 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // Unlike other linked_ptr implementations, in this implementation
59 // a linked_ptr object is thread-safe in the sense that:
60 // - it's safe to copy linked_ptr objects concurrently,
61 // - it's safe to copy *from* a linked_ptr and read its underlying
66 // confusion with normal linked_ptr
136 class linked_ptr { class in namespace:testing::internal
142 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
146 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
147 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/chromium_org/third_party/libvpx/source/libvpx/third_party/googletest/src/include/gtest/
H A Dgtest.h9004 // - References are only tracked as long as linked_ptr<> objects are copied.
9005 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
9009 // You can safely put linked_ptr<> in a vector<>.
9012 // Note: If you use an incomplete type with linked_ptr<>, the class
9013 // *containing* linked_ptr<> must have a constructor and destructor (even
9019 // Unlike other linked_ptr implementations, in this implementation
9020 // a linked_ptr object is thread-safe in the sense that:
9021 // - it's safe to copy linked_ptr objects concurrently,
9022 // - it's safe to copy *from* a linked_ptr and read its underlying
9027 // confusion with normal linked_ptr
9096 class linked_ptr { class in namespace:testing::internal
9102 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
9106 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
9107 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]
/external/libvpx/libvpx/third_party/googletest/src/include/gtest/
H A Dgtest.h9004 // - References are only tracked as long as linked_ptr<> objects are copied.
9005 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
9009 // You can safely put linked_ptr<> in a vector<>.
9012 // Note: If you use an incomplete type with linked_ptr<>, the class
9013 // *containing* linked_ptr<> must have a constructor and destructor (even
9019 // Unlike other linked_ptr implementations, in this implementation
9020 // a linked_ptr object is thread-safe in the sense that:
9021 // - it's safe to copy linked_ptr objects concurrently,
9022 // - it's safe to copy *from* a linked_ptr and read its underlying
9027 // confusion with normal linked_ptr
9096 class linked_ptr { class in namespace:testing::internal
9102 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
9106 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
9107 linked_ptr(linked_ptr const& ptr) { // NOLINT function in class:testing::internal::linked_ptr
[all...]

Completed in 501 milliseconds