48 #ifdef HAVE_TEUCHOS_BOOST
51 #ifdef HAVE_TEUCHOSCORE_CXX11
68 using Teuchos::rcpFromRef;
69 using Teuchos::rcpFromUndefRef;
70 using Teuchos::outArg;
71 using Teuchos::rcpWithEmbeddedObj;
72 using Teuchos::getEmbeddedObj;
73 using Teuchos::getOptionalEmbeddedObj;
74 using Teuchos::getOptionalNonconstEmbeddedObj;
75 using Teuchos::set_extra_data;
76 using Teuchos::get_optional_nonconst_extra_data;
156 RCP<A> b_rcp(std::move(a_rcp));
183 A *a_raw_ptr = a_rcp.getRawPtr();
212 b_rcp = std::move(a_rcp);
266 RCP<const A> ca_rcp = a_rcp.getConst();
287 RCP<A> a_rcp(0,
null);
295 RCP<A> a_rcp(a,
null);
312 RCP<A> a_rcp1 = rcp<A>(
new A);
315 if (RCPNodeTracer::isTracingActiveRCPNodes())
373 ECHO(RCP<int> rcp1 =
rcp(
new int(0)));
380 ECHO(RCP<int> rcp3 = rcp2);
385 ECHO(RCP <int> rcp4 = rcp1);
425 ECHO(
A *a_ptr = c_ptr);
426 ECHO(RCP<C> c_rcp =
rcp(c_ptr));
427 #if defined(TEUCHOS_DEBUG) && defined(HAS_TEUCHOS_GET_BASE_OBJ_VOID_PTR)
429 TEST_THROW(RCP<A> a_rcp =
rcp(a_ptr), DuplicateOwningRCPError);
432 ECHO(RCP<A> a_rcp =
rcp(a_ptr));
447 ECHO(
A *a_ptr2 = a_ptr1);
448 ECHO(RCP<A> a_rcp1 =
rcp(a_ptr1));
449 #if defined(TEUCHOS_DEBUG)
451 TEST_THROW(RCP<A> a_rcp2 =
rcp(a_ptr2), DuplicateOwningRCPError);
454 ECHO(RCP<A> a_rcp2 =
rcp(a_ptr2));
456 ECHO(a_rcp2.release());
469 ECHO(
E *d_ptr = e_ptr);
470 ECHO(RCP<E> e_rcp =
rcp(e_ptr));
471 #if defined(TEUCHOS_DEBUG)
474 TEST_THROW(RCP<D> d_rcp =
rcp(d_ptr), DuplicateOwningRCPError);
477 ECHO(RCP<D> d_rcp =
rcp(d_ptr));
479 ECHO(d_rcp.release());
498 ECHO(RCP<C> c_rcp(
new C));
499 ECHO(
A &a_ref = *c_rcp);
500 ECHO(RCP<A> a_rcp =
rcp(&a_ref,
false));
502 #if defined(TEUCHOS_DEBUG) && defined(HAS_TEUCHOS_GET_BASE_OBJ_VOID_PTR)
513 ECHO(RCP<A> a_rcp1(
new C));
514 ECHO(
A &a_ref = *a_rcp1);
515 ECHO(RCP<A> a_rcp2 =
rcp(&a_ref,
false));
517 #if defined(TEUCHOS_DEBUG)
518 TEST_THROW(a_rcp2->A_g(), DanglingReferenceError);
528 ECHO(RCP<E> e_rcp(
new E));
529 ECHO(
D &d_ref = *e_rcp);
530 ECHO(RCP<D> d_rcp =
rcp(&d_ref,
false));
532 #if defined(TEUCHOS_DEBUG)
533 TEST_THROW(d_rcp->D_g(), DanglingReferenceError);
543 TEUCHOS_UNIT_TEST( RCP, rcpFromRef_duplicate_rcp_nonowning_polymorphic_different_addr )
546 ECHO(RCP<C> c_rcp(
new C));
547 ECHO(
A &a_ref = *c_rcp);
550 #if defined(TEUCHOS_DEBUG) && defined(HAS_TEUCHOS_GET_BASE_OBJ_VOID_PTR)
558 TEUCHOS_UNIT_TEST( RCP, rcpFromRef_duplicate_rcp_nonowning_polymorphic_same_addr )
561 ECHO(RCP<A> a_rcp1(
new C));
562 ECHO(
A &a_ref = *a_rcp1);
565 #if defined(TEUCHOS_DEBUG)
566 TEST_THROW(a_rcp2->A_g(), DanglingReferenceError);
576 ECHO(RCP<E> e_rcp(
new E));
577 ECHO(
D &d_ref = *e_rcp);
580 #if defined(TEUCHOS_DEBUG)
581 TEST_THROW(d_rcp->D_g(), DanglingReferenceError);
591 TEUCHOS_UNIT_TEST( RCP, rcpFromUndefRef_duplicate_rcp_nonowning_polymorphic_same_addr )
594 ECHO(RCP<A> a_rcp1(
new C));
595 ECHO(
A &a_ref = *a_rcp1);
609 RCP<A> a_rcp =
rcp(
new A);
618 const Ptr<const RCP<C> > c_ptr_rcp_1 =
619 getOptionalEmbeddedObj<A, RCP<C> >(a_rcp);
621 const Ptr<RCP<C> > c_ptr_rcp_2 =
622 getOptionalNonconstEmbeddedObj<A, RCP<C> >(a_rcp);
633 Ptr<const RCP<C> > c_ptr_rcp_1 =
634 getOptionalEmbeddedObj<A, RCP<C> >(a_rcp);
636 TEST_EQUALITY( (*c_ptr_rcp_1).getRawPtr(), c_rcp.getRawPtr() );
639 Ptr<RCP<C> > c_ptr_rcp_2 =
640 getOptionalNonconstEmbeddedObj<A, RCP<C> >(a_rcp);
642 TEST_EQUALITY( (*c_ptr_rcp_2).getRawPtr(), c_rcp.getRawPtr() );
650 RCP<A> a_rcp =
rcp(
new A);
658 RCP<A> a_rcp =
rcp(
new A);
680 ECHO(RCP<T> rcp_strong =
rcp(
new T));
688 ECHO(RCP<T> rcp_weak1 = rcp_strong.create_weak());
705 TEST_EQUALITY( rcp_weak1.getRawPtr(), rcp_strong.getRawPtr() );
707 ECHO(RCP<T> rcp_weak2 = rcp_weak1);
725 TEST_EQUALITY( rcp_weak2.getRawPtr(), rcp_strong.getRawPtr() );
756 ECHO(rcp_weak1.assert_not_null());
757 ECHO(rcp_weak2.assert_not_null());
759 TEST_THROW( rcp_weak1.assert_valid_ptr(), DanglingReferenceError );
761 TEST_THROW( rcp_weak1.operator->(), DanglingReferenceError );
762 TEST_THROW( *rcp_weak1, DanglingReferenceError );
763 TEST_THROW( rcp_weak1.create_weak(), DanglingReferenceError );
764 TEST_THROW( rcp_weak1.get(), DanglingReferenceError );
765 TEST_THROW( rcp_weak1.getRawPtr(), DanglingReferenceError );
766 TEST_THROW( rcp_weak1(), DanglingReferenceError );
767 TEST_THROW( rcp_weak1.release(), DanglingReferenceError );
768 #endif // TEUCHOS_DEBUG
789 TEST_THROW( rcp_weak2.assert_valid_ptr(), DanglingReferenceError );
791 TEST_THROW( rcp_weak2.operator->(), DanglingReferenceError );
792 TEST_THROW( *rcp_weak2, DanglingReferenceError );
793 TEST_THROW( rcp_weak2.create_weak(), DanglingReferenceError );
794 TEST_THROW( rcp_weak2.get(), DanglingReferenceError );
795 TEST_THROW( rcp_weak2.getRawPtr(), DanglingReferenceError );
796 TEST_THROW( rcp_weak2(), DanglingReferenceError );
797 TEST_THROW( rcp_weak2.release(), DanglingReferenceError );
798 #endif // TEUCHOS_DEBUG
809 ECHO(RCP<A> rcp2 = rcp1.create_weak());
817 ECHO(RCP<A> rcp3 = rcp2.create_strong());
849 ECHO(c->set_A(a.create_weak()));
862 TEST_THROW(c->call_A_g(), DanglingReferenceError);
881 ECHO(c->set_A(a.create_weak()));
912 ECHO(c->set_A(c.create_weak()));
922 ECHO(Ptr<A> a_ptr = a_rcp());
923 ECHO(
A *badPtr = a_rcp.getRawPtr());
940 ECHO(badPtr = a_rcp.getRawPtr());
941 ECHO(a_ptr = a_rcp.ptr());
959 ECHO(badPtr = a_rcp.getRawPtr());
960 ECHO(Ptr<A> a_ptr2(a_rcp.ptr()));
961 ECHO(Ptr<A> a_ptr3(a_ptr2));
962 ECHO(a_ptr = a_ptr3);
980 ECHO(badPtr = c_rcp.getRawPtr());
981 ECHO(Ptr<A> a_ptr2(c_rcp.ptr()));
982 ECHO(a_ptr = a_ptr2);
1020 #endif // TEUCHOS_DEBUG
1028 RCP<C> createCAFactory()
1030 RCP<C> c =
rcp(
new C);
1031 c->set_A(
rcp(
new A));
1036 RCP<A> createACFactory()
1038 RCP<C> c = createCAFactory();
1039 return Teuchos::rcpWithInvertedObjOwnership(c->get_A(), c);
1043 RCP<C> extractCFromA(
const RCP<A> &a)
1045 return Teuchos::getInvertedObjOwnershipParent<C>(a);
1051 RCP<A> a = createACFactory();
1052 RCP<C> c = extractCFromA(a);
1066 RCP<A> a = createACFactory();
1067 extractCFromA(a)->set_A(
null);
1068 RCP<C> c = extractCFromA(a);
1081 RCP<A> createRCPWithBadDealloc()
1083 return rcp(
new A[1]);
1087 template<
typename T>
1088 class DeallocArrayDeleteExtraData {
1090 static RCP<DeallocArrayDeleteExtraData<T> > create(T *ptr)
1091 {
return rcp(
new DeallocArrayDeleteExtraData(ptr)); }
1092 ~DeallocArrayDeleteExtraData() {
delete [] ptr_; }
1095 DeallocArrayDeleteExtraData(T *ptr) : ptr_(ptr) {}
1097 DeallocArrayDeleteExtraData();
1098 DeallocArrayDeleteExtraData(
const DeallocArrayDeleteExtraData&);
1099 DeallocArrayDeleteExtraData& operator=(
const DeallocArrayDeleteExtraData&);
1107 using Teuchos::inOutArg;
1108 using Teuchos::set_extra_data;
1110 RCP<A> a = createRCPWithBadDealloc();
1114 set_extra_data( DeallocArrayDeleteExtraData<A>::create(a.getRawPtr()),
"dealloc",
1141 #ifdef HAVE_TEUCHOS_BOOST
1146 using boost::shared_ptr;
1147 ECHO(shared_ptr<A> a_sptr(
new A));
1150 ECHO(a_sptr = shared_ptr<A>());
1156 #endif // HAVE_TEUCHOS_BOOST
1164 #ifdef HAVE_TEUCHOSCORE_CXX11
1169 using std::shared_ptr;
1170 ECHO(shared_ptr<A> a_sptr(
new A));
1173 ECHO(a_sptr = shared_ptr<A>());
1181 const std::shared_ptr<A> a_sptr1;
1182 const RCP<A> a_rsptr1 =
rcp(a_sptr1);
1194 const std::shared_ptr<A> a_sptr1(
new C());
1195 const RCP<A> a_rsptr1 =
rcp(a_sptr1);
1209 const RCP<A> a_rcp1;
1214 const RCP<A> a_rcp2 =
rcp(a_sptr1);
1222 const RCP<A> a_rcp1(
new C());
1228 const RCP<A> a_rcp2 =
rcp(a_sptr1);
1235 #ifdef TEUCHOS_DEBUG
1240 const RCP<A> a_rcp1(
new C());
1244 const RCP<C> c_rcp1 =
rcp(std::dynamic_pointer_cast<C>(a_sptr1));
1252 #endif // TEUCHOS_DEBUG
1255 #endif // HAVE_TEUCHOSCORE_CXX11
1264 #ifdef TEUCHOS_DEBUG
1266 # define DEBUG_UNIT_TEST_GROUP( T ) \
1270 # define DEBUG_UNIT_TEST_GROUP( T )
1275 #define UNIT_TEST_GROUP( T ) \
1276 TEUCHOS_UNIT_TEST_TEMPLATE_1_INSTANT( RCP, weakDelete, T ) \
1277 DEBUG_UNIT_TEST_GROUP(T)
Dangling reference error exception class.
Null reference error exception class.
RCP< T > rcp(const boost::shared_ptr< T > &sptr)
Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...
void set_extra_data(const T1 &extra_data, const std::string &name, const Ptr< ArrayRCP< T2 > > &p, EPrePostDestruction destroy_when=POST_DESTROY, bool force_unique=true)
Set extra data associated with a ArrayRCP object.
void set_C(const Teuchos::RCP< C > &c)
#define TEST_ASSERT(v1)
Assert the given statement is true.
Ptr< T > inOutArg(T &arg)
create a non-persisting (required or optional) input/output argument for a function call...
#define TEST_INEQUALITY_CONST(v1, v2)
Assert the inequality of v1 and constant v2.
Ptr< T1 > get_optional_nonconst_extra_data(RCP< T2 > &p, const std::string &name)
Get a pointer to non-const extra data (if it exists) associated with a RCP object.
#define TEST_NOTHROW(code)
Asserr that the statement 'code' does not thrown any excpetions.
#define ECHO(statement)
Echo the given statement before it is executed.
bool nonnull(const std::shared_ptr< T > &p)
Returns true if p.get()!=NULL.
bool is_null(const std::shared_ptr< T > &p)
Returns true if p.get()==NULL.
#define TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL(TEST_GROUP, TEST_NAME, TYPE)
Macro for defining a templated unit test with one template parameter.
#define TEST_EQUALITY(v1, v2)
Assert the equality of v1 and v2.
#define TEST_THROW(code, ExceptType)
Assert that the statement 'code' throws the exception 'ExceptType' (otherwise the test fails)...
const T & getConst(T &t)
Return a constant reference to an object given a non-const reference.
T * get() const
Get the raw C++ pointer to the underlying object.
#define TEUCHOS_UNIT_TEST(TEST_GROUP, TEST_NAME)
Macro for defining a (non-templated) unit test.
bool is_null(const ArrayRCP< T > &p)
Returns true if p.get()==NULL.
RCP< T > rcpWithEmbeddedObj(T *p, const Embedded &embedded, bool owns_mem=true)
Create an RCP with and also put in an embedded object.
void free(T *ptr)
Deallocates a pointer ptr using delete ptr (required).
Debug-mode RCPNode tracing class.
T * getRawPtr() const
Get the raw C++ pointer to the underlying object.
RCP< T > rcpCloneNode(const RCP< T > &p)
Allocate a new RCP object with a new RCPNode with memory pointing to the initial node.
#define SET_RCPNODE_TRACING()
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
#define TEST_EQUALITY_CONST(v1, v2)
Assert the equality of v1 and constant v2.
TypeTo as(const TypeFrom &t)
Convert from one value type to another.
Ptr< T > release()
Release the ownership of the underlying dynamically allocated object.
RCP< T > rcpFromUndefRef(T &r)
Return a non-owning weak RCP object from a raw object reference for an undefined type.
std::shared_ptr< T > get_shared_ptr(const RCP< T > &rcp)
Conversion function that takes in a Teuchos::RCP object and spits out a std::shared_ptr object...
RCP< T > rcpFromRef(T &r)
Return a non-owning weak RCP object from a raw object reference for a defined type.
Policy class for deallocator for non-owned RCPs.
Smart reference counting pointer class for automatic garbage collection.
RCP< T > rcpWithDealloc(T *p, Dealloc_T dealloc, bool owns_mem=true)
Initialize from a raw pointer with a deallocation policy.
Ptr< T > outArg(T &arg)
create a non-persisting (required or optional) output argument for a function call.
Thrown if a duplicate owning RCP is creatd the the same object.
Reference-counted pointer class and non-member templated function implementations.
Simple wrapper class for raw pointers to single objects where no persisting relationship exists...
auto make_rcp(Args &&...args)
bool nonnull(const ArrayRCP< T > &p)
Returns true if p.get()!=NULL.
#define UNIT_TEST_GROUP(T)