| /external/google-breakpad/src/processor/ |
| H A D | linked_ptr.h | 41 // - References are only tracked as long as linked_ptr<> objects are copied.
42 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
46 // You can safely put linked_ptr<> in a vector<>.
49 // Note: If you use an incomplete type with linked_ptr<>, the class
50 // *containing* linked_ptr<> must have a constructor and destructor (even
58 // This is used internally by all instances of linked_ptr<>. It needs to be
59 // a non-template class because different types of linked_ptr<> can refer to
60 // the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
61 // So, it needs to be possible for different types of linked_ptr t
95 class linked_ptr { class in namespace:google_breakpad
101 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:google_breakpad::linked_ptr
105 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:google_breakpad::linked_ptr
106 linked_ptr(linked_ptr const& ptr) { copy(&ptr); } function in class:google_breakpad::linked_ptr
[all...] |
| /external/google-breakpad/src/testing/gtest/include/gtest/internal/ |
| H A D | gtest-linked_ptr.h | 43 // - 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 D | gtest-linked_ptr.h | 43 // - 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 D | gtest-linked_ptr.h | 43 // - 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 D | gtest-linked_ptr.h | 43 // - 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 D | gtest-linked_ptr.h | 43 // - 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/fused-src/gtest/ |
| H A D | gtest.h | 8345 // - References are only tracked as long as linked_ptr<> objects are copied.
8346 // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
8350 // You can safely put linked_ptr<> in a vector<>.
8353 // Note: If you use an incomplete type with linked_ptr<>, the class
8354 // *containing* linked_ptr<> must have a constructor and destructor (even
8360 // Unlike other linked_ptr implementations, in this implementation
8361 // a linked_ptr object is thread-safe in the sense that:
8362 // - it's safe to copy linked_ptr objects concurrently,
8363 // - it's safe to copy *from* a linked_ptr and read its underlying
8368 // confusion with normal linked_ptr
8437 class linked_ptr { class in namespace:testing::internal
8443 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:testing::internal::linked_ptr
8447 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:testing::internal::linked_ptr
8448 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 D | gtest.h | 9004 // - 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...] |