/external/libchrome/base/memory/ |
H A D | linked_ptr.h | 16 // - 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 20 // Note: If you use an incomplete type with linked_ptr<>, the class 21 // *containing* linked_ptr<> must have a constructor and destructor (even 25 // A linked_ptr is NOT thread safe. Copying a linked_ptr object is 28 // Alternative: to linked_ptr is shared_ptr, which 38 // This is used internally by all instances of linked_ptr<>. It needs to be 39 // a non-template class because different types of linked_ptr<> can refer to 40 // the same object (linked_ptr<Superclas 75 class linked_ptr { class 81 explicit linked_ptr(T* ptr = NULL) { capture(ptr); } function in class:linked_ptr 85 template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } function in class:linked_ptr 87 linked_ptr(linked_ptr const& ptr) { function in class:linked_ptr [all...] |
H A D | linked_ptr_unittest.cc | 7 #include "base/memory/linked_ptr.h" 36 linked_ptr<A> a0, a1, a2; 47 linked_ptr<A> a3(new A); 53 linked_ptr<A> a4(a0); 55 linked_ptr<A> a5(new A); 59 linked_ptr<B> b0(new B); 60 linked_ptr<A> a6(b0); 83 linked_ptr<A> a7;
|
/external/webrtc/webrtc/base/ |
H A D | linked_ptr.h | 12 * 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/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...] |
H A D | basic_code_modules.cc | 42 #include "processor/linked_ptr.h" 50 map_(new RangeMap<uint64_t, linked_ptr<const CodeModule> >()) { 67 linked_ptr<const CodeModule> module( 78 map_(new RangeMap<uint64_t, linked_ptr<const CodeModule> >()) { 91 linked_ptr<const CodeModule> module; 106 linked_ptr<const CodeModule> module;
|
H A D | address_map_unittest.cc | 38 #include "processor/linked_ptr.h" 54 using google_breakpad::linked_ptr; 74 typedef AddressMap< AddressType, linked_ptr<CountedObject> > TestMap; 80 linked_ptr<CountedObject> entry; 91 linked_ptr<CountedObject>(new CountedObject(0)))); 104 linked_ptr<CountedObject>(new CountedObject(1)))); 115 linked_ptr<CountedObject>(new CountedObject(2)))); 118 linked_ptr<CountedObject>(new CountedObject(3)))); 120 linked_ptr<CountedObject>(new CountedObject(4)))); 122 linked_ptr<CountedObjec [all...] |
H A D | basic_code_modules.h | 48 template<typename T> class linked_ptr; 78 RangeMap<uint64_t, linked_ptr<const CodeModule> > *map_;
|
H A D | basic_source_line_resolver_types.h | 51 #include "processor/linked_ptr.h" 68 RangeMap< MemAddr, linked_ptr<Line> > lines; 145 RangeMap< MemAddr, linked_ptr<Function> > functions_; 146 AddressMap< MemAddr, linked_ptr<PublicSymbol> > public_symbols_; 153 ContainedRangeMap< MemAddr, linked_ptr<WindowsFrameInfo> >
|
H A D | module_serializer.h | 47 #include "processor/linked_ptr.h" 117 RangeMapSerializer<MemAddr, linked_ptr<Function> > functions_serializer_; 118 AddressMapSerializer<MemAddr, linked_ptr<PublicSymbol> > pubsym_serializer_; 120 linked_ptr<WindowsFrameInfo> > wfi_serializer_;
|
H A D | simple_serializer-inl.h | 48 #include "processor/linked_ptr.h" 170 class SimpleSerializer< linked_ptr<BasicSourceLineResolver::Line> > { 173 static size_t SizeOf(const linked_ptr<Line> &lineptr) { 177 static char *Write(const linked_ptr<Line> &lineptr, char *dest) { 210 static RangeMapSerializer< MemAddr, linked_ptr<Line> > range_map_serializer_; 214 class SimpleSerializer< linked_ptr<BasicSourceLineResolver::Function> > { 217 static size_t SizeOf(const linked_ptr<Function> &func) { 222 static char *Write(const linked_ptr<Function> &func, char *dest) { 230 class SimpleSerializer< linked_ptr<BasicSourceLineResolver::PublicSymbol> > { 233 static size_t SizeOf(const linked_ptr<PublicSymbo [all...] |
H A D | range_map_unittest.cc | 41 #include "processor/linked_ptr.h" 47 using google_breakpad::linked_ptr; 71 typedef RangeMap< AddressType, linked_ptr<CountedObject> > TestMap; 106 linked_ptr<CountedObject> object(new CountedObject(range_test->id)); 166 linked_ptr<CountedObject> object; 210 linked_ptr<CountedObject> nearest_object; 270 linked_ptr<CountedObject> object; 337 linked_ptr<CountedObject> object(new CountedObject(object_id)); 342 linked_ptr<CountedObject> object;
|
H A D | basic_source_line_resolver.cc | 87 linked_ptr<Function> cur_func; 177 linked_ptr<Line>(line)); 199 linked_ptr<Function> func; 200 linked_ptr<PublicSymbol> public_symbol; 210 linked_ptr<Line> line; 239 linked_ptr<WindowsFrameInfo> frame_info; 255 linked_ptr<Function> function; 267 linked_ptr<PublicSymbol> public_symbol; 365 linked_ptr<PublicSymbol> symbol(new PublicSymbol(name, address, 389 linked_ptr<WindowsFrameInf [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/vulkan-validation-layers/tests/gtest-1.7.0/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/test/ |
H A D | gtest-linked_ptr_test.cc | 33 #include <gtest/internal/gtest-linked_ptr.h> 41 using testing::internal::linked_ptr; 79 linked_ptr<A> a0, a1, a2; 90 linked_ptr<A> a3(new A); 96 linked_ptr<A> a4(a0); 98 linked_ptr<A> a5(new A); 102 linked_ptr<B> b0(new B); 103 linked_ptr<A> a6(b0); 126 linked_ptr<A> a7;
|
/external/google-breakpad/src/testing/gtest/test/ |
H A D | gtest-linked_ptr_test.cc | 33 #include "gtest/internal/gtest-linked_ptr.h" 41 using testing::internal::linked_ptr; 79 linked_ptr<A> a0, a1, a2; 91 linked_ptr<A> a3(new A); 97 linked_ptr<A> a4(a0); 99 linked_ptr<A> a5(new A); 103 linked_ptr<B> b0(new B); 104 linked_ptr<A> a6(b0); 127 linked_ptr<A> a7;
|
/external/gtest/test/ |
H A D | gtest-linked_ptr_test.cc | 33 #include "gtest/internal/gtest-linked_ptr.h" 41 using testing::internal::linked_ptr; 79 linked_ptr<A> a0, a1, a2; 91 linked_ptr<A> a3(new A); 97 linked_ptr<A> a4(a0); 99 linked_ptr<A> a5(new A); 103 linked_ptr<B> b0(new B); 104 linked_ptr<A> a6(b0); 127 linked_ptr<A> a7;
|
/external/vulkan-validation-layers/tests/gtest-1.7.0/test/ |
H A D | gtest-linked_ptr_test.cc | 33 #include "gtest/internal/gtest-linked_ptr.h" 41 using testing::internal::linked_ptr; 79 linked_ptr<A> a0, a1, a2; 91 linked_ptr<A> a3(new A); 97 linked_ptr<A> a4(a0); 99 linked_ptr<A> a5(new A); 103 linked_ptr<B> b0(new B); 104 linked_ptr<A> a6(b0); 127 linked_ptr<A> a7;
|
/external/google-breakpad/src/google_breakpad/processor/ |
H A D | call_stack.h | 34 // pointers without having to publicly export the linked_ptr class. A 55 template<typename T> class linked_ptr;
|
/external/gmock/test/ |
H A D | gmock_stress_test.cc | 64 using internal::linked_ptr; 66 // Helper classes for testing using linked_ptr concurrently. 93 linked_ptr<Derived1> pointer1(new Derived1(1, 2)); 94 linked_ptr<Derived2> pointer2(new Derived2(3, 4)); 98 // Tests that we can copy from a linked_ptr and read it concurrently. 108 linked_ptr<Derived1> p1(pointer1); 113 linked_ptr<Base> p2; 122 const linked_ptr<Derived1> p0(new Derived1(1, 2)); 130 linked_ptr<Derived1> p1(p0); 131 linked_ptr<Derived [all...] |
/external/google-breakpad/src/testing/test/ |
H A D | gmock_stress_test.cc | 64 using internal::linked_ptr; 66 // Helper classes for testing using linked_ptr concurrently. 93 linked_ptr<Derived1> pointer1(new Derived1(1, 2)); 94 linked_ptr<Derived2> pointer2(new Derived2(3, 4)); 98 // Tests that we can copy from a linked_ptr and read it concurrently. 108 linked_ptr<Derived1> p1(pointer1); 113 linked_ptr<Base> p2; 122 const linked_ptr<Derived1> p0(new Derived1(1, 2)); 130 linked_ptr<Derived1> p1(p0); 131 linked_ptr<Derived [all...] |