Teuchos - Trilinos Tools Package Version of the Day
Loading...
Searching...
No Matches
Teuchos_RCP.hpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Teuchos: Common Tools Package
5// Copyright (2004) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38//
39// ***********************************************************************
40// @HEADER
41
42#ifndef TEUCHOS_RCP_HPP
43#define TEUCHOS_RCP_HPP
44
45
58#include "Teuchos_RCPDecl.hpp"
59#include "Teuchos_Ptr.hpp"
60#include "Teuchos_Assert.hpp"
61#include "Teuchos_Exceptions.hpp"
62#include "Teuchos_dyn_cast.hpp"
63#include "Teuchos_map.hpp"
65
66
67namespace Teuchos {
68
69
70// very bad public functions
71
72
73template<class T>
74inline
75RCPNode* RCP_createNewRCPNodeRawPtrNonowned( T* p )
76{
77 return new RCPNodeTmpl<T,DeallocNull<T> >(p, DeallocNull<T>(), false);
78}
79
80
81template<class T>
82inline
83RCPNode* RCP_createNewRCPNodeRawPtrNonownedUndefined( T* p )
84{
85 return new RCPNodeTmpl<T,DeallocNull<T> >(p, DeallocNull<T>(), false, null);
86}
87
88
89template<class T>
90inline
91RCPNode* RCP_createNewRCPNodeRawPtr( T* p, bool has_ownership_in )
92{
93 return new RCPNodeTmpl<T,DeallocDelete<T> >(p, DeallocDelete<T>(), has_ownership_in);
94}
95
96
97template<class T, class Dealloc_T>
98inline
99RCPNode* RCP_createNewDeallocRCPNodeRawPtr(
100 T* p, Dealloc_T dealloc, bool has_ownership_in
101 )
102{
103 return new RCPNodeTmpl<T,Dealloc_T>(p, dealloc, has_ownership_in);
104}
105
106
107template<class T, class Dealloc_T>
108inline
109RCPNode* RCP_createNewDeallocRCPNodeRawPtrUndefined(
110 T* p, Dealloc_T dealloc, bool has_ownership_in
111 )
112{
113 return new RCPNodeTmpl<T,Dealloc_T>(p, dealloc, has_ownership_in, null);
114}
115
116
117template<class T>
118inline
119RCP<T>::RCP( T* p, const RCPNodeHandle& node)
120 : ptr_(p), node_(node)
121{}
122
123
124template<class T>
125inline
126T* RCP<T>::access_private_ptr() const
127{ return ptr_; }
128
129
130template<class T>
131inline
132RCPNodeHandle& RCP<T>::nonconst_access_private_node()
133{ return node_; }
134
135
136template<class T>
137inline
138const RCPNodeHandle& RCP<T>::access_private_node() const
139{ return node_; }
140
141
142
143
144// Constructors/destructors/initializers
145
146
147template<class T>
148inline
150 : ptr_(NULL)
151{}
152
153
154template<class T>
155inline
156RCP<T>::RCP( T* p, ERCPWeakNoDealloc )
157 : ptr_(p)
159 , node_(RCP_createNewRCPNodeRawPtrNonowned(p))
160#endif // TEUCHOS_DEBUG
161{
162#ifdef TEUCHOS_DEBUG
163 if (p) {
165 if (existing_RCPNode) {
166 // Will not call add_new_RCPNode(...)
167 node_ = RCPNodeHandle(existing_RCPNode, RCP_WEAK, false);
168 }
169 else {
170 // Will call add_new_RCPNode(...)
171 node_ = RCPNodeHandle(
172 RCP_createNewRCPNodeRawPtrNonowned(p),
174 false
175 );
176 }
177 }
178#endif // TEUCHOS_DEBUG
179}
180
181
182template<class T>
183inline
184RCP<T>::RCP( T* p, ERCPUndefinedWeakNoDealloc )
185 : ptr_(p),
186 node_(RCP_createNewRCPNodeRawPtrNonownedUndefined(p))
187{}
188
189
190template<class T>
191inline
193 : ptr_(p)
195 , node_(RCP_createNewRCPNodeRawPtr(p, has_ownership_in))
196#endif // TEUCHOS_DEBUG
197{
198#ifdef TEUCHOS_DEBUG
199 if (p) {
201 if (!has_ownership_in) {
203 }
204 if (existing_RCPNode) {
205 // Will not call add_new_RCPNode(...)
206 node_ = RCPNodeHandle(existing_RCPNode, RCP_WEAK, false);
207 }
208 else {
209 // Will call add_new_RCPNode(...)
210 RCPNodeThrowDeleter nodeDeleter(RCP_createNewRCPNodeRawPtr(p, has_ownership_in));
211 node_ = RCPNodeHandle(
215 );
217 }
218 }
219#endif // TEUCHOS_DEBUG
220}
221
222
223template<class T>
224template<class Dealloc_T>
225inline
227 : ptr_(p)
229 , node_(RCP_createNewDeallocRCPNodeRawPtr(p, dealloc, has_ownership_in))
230#endif // TEUCHOS_DEBUG
231{
232#ifdef TEUCHOS_DEBUG
233 if (p) {
234 // Here we are assuming that if the user passed in a custom deallocator
235 // then they will want to have ownership (otherwise it will throw if it is
236 // the same object).
237 RCPNodeThrowDeleter nodeDeleter(RCP_createNewDeallocRCPNodeRawPtr(p, dealloc, has_ownership_in));
238 node_ = RCPNodeHandle(
242 );
244 }
245#endif // TEUCHOS_DEBUG
246}
247
248
249template<class T>
250template<class Dealloc_T>
251inline
252RCP<T>::RCP( T* p, Dealloc_T dealloc, ERCPUndefinedWithDealloc, bool has_ownership_in )
253 : ptr_(p)
255 , node_(RCP_createNewDeallocRCPNodeRawPtrUndefined(p, dealloc, has_ownership_in))
256#endif // TEUCHOS_DEBUG
257{
258#ifdef TEUCHOS_DEBUG
259 if (p) {
260 // Here we are assuming that if the user passed in a custom deallocator
261 // then they will want to have ownership (otherwise it will throw if it is
262 // the same object).
263 // Use auto_ptr to ensure we don't leak if a throw occurs
264 RCPNodeThrowDeleter nodeDeleter(RCP_createNewDeallocRCPNodeRawPtrUndefined(
266 node_ = RCPNodeHandle(
270 );
272 }
273#endif // TEUCHOS_DEBUG
274}
275
276
277template<class T>
278inline
280 : ptr_(r_ptr.ptr_), node_(r_ptr.node_)
281{}
282
283
284template<class T>
285inline
287 : ptr_(r_ptr.ptr_), node_(std::move(r_ptr.node_))
288{
289 r_ptr.ptr_ = 0;
290}
291
292
293template<class T>
294template<class T2>
295inline
297 : ptr_(r_ptr.get()), // will not compile if T is not base class of T2
299{}
300
301
302template<class T>
303template<class T2>
304inline
306 : ptr_(ptr),
308{}
309
310
311template<class T>
312inline
315
316
317template<class T>
318inline
320{
321#ifdef TEUCHOS_DEBUG
322 if (this == &r_ptr)
323 return *this;
324 reset(); // Force delete first in debug mode!
325#endif
326 RCP<T>(r_ptr).swap(*this);
327 return *this;
328}
329
330
331template<class T>
332inline
334{
335#ifdef TEUCHOS_DEBUG
336 if (this == &r_ptr)
337 return *this;
338 reset(); // Force delete first in debug mode!
339#endif
340 ptr_ = r_ptr.ptr_;
341 node_ = std::move(r_ptr.node_);
342 r_ptr.ptr_ = 0;
343 return *this;
344}
345
346
347template<class T>
348inline
350{
351 reset();
352 return *this;
353}
354
355
356template<class T>
357inline
359{
360 std::swap(r_ptr.ptr_, ptr_);
361 node_.swap(r_ptr.node_);
362}
363
364
365// Object query and access functions
366
367
368template<class T>
369inline
370bool RCP<T>::is_null() const
371{
372 return ptr_ == 0;
373}
374
375
376template<class T>
377inline
379{
382 return ptr_;
383}
384
385
386template<class T>
387inline
389{
392 return *ptr_;
393}
394
395template<class T>
396inline
398{
400 return ptr_;
401}
402
403
404template<class T>
405inline
407{
408 return this->get();
409}
410
411
412template<class T>
413inline
415{
416#ifdef TEUCHOS_DEBUG
417 return Ptr<T>(this->create_weak());
418#else
419 return Ptr<T>(getRawPtr());
420#endif
421}
422
423
424template<class T>
425inline
427{
428 return ptr();
429}
430
431
432template<class T>
433inline
435{
436 return rcp_implicit_cast<const T>(*this);
437}
438
439
440template<class T>
441inline
443{
444 return (get() != 0);
445}
446
447
448// Reference counting
449
450
451template<class T>
452inline
454{
455 return node_.strength();
456}
457
458
459template<class T>
460inline
462{
463 if (ptr_)
464 return node_.is_valid_ptr();
465 return true;
466}
467
468
469template<class T>
470inline
472{
473 return node_.strong_count();
474}
475
476
477template<class T>
478inline
480{
481 return node_.weak_count();
482}
483
484
485template<class T>
486inline
488{
489 return node_.total_count();
490}
491
492
493template<class T>
494inline
496{
497 node_.has_ownership(true);
498}
499
500
501template<class T>
502inline
504{
505 return node_.has_ownership();
506}
507
508
509template<class T>
510inline
512{
514 node_.has_ownership(false);
515 return Ptr<T>(ptr_);
516}
517
518
519template<class T>
520inline
524 return RCP<T>(ptr_, node_.create_weak());
525}
526
527
528template<class T>
529inline
533 return RCP<T>(ptr_, node_.create_strong());
534}
535
536#if defined(HAVE_TEUCHOSCORE_CXX11) && defined(HAVE_TEUCHOS_THREAD_SAFE)
537template<class T>
538inline
540{
541 if (strength() == RCP_STRONG) {
542 return create_strong(); // it's already thread safe
543 }
544 // we don't check for debug_assert_valid_ptr()
545 // probably doesn't hurt anything if we do but using it would be confusing
546 // because ptr could become invalid immediately after
548 return RCP<T>( attemptStrong.is_node_null() ? 0 : ptr_, attemptStrong);
549}
550#endif
551
552
553template<class T>
554template <class T2>
555inline
557{
558 return node_.same_node(r_ptr.access_private_node());
559 // Note: above, r_ptr is *not* the same class type as *this so we can not
560 // access its node_ member directly! This is an interesting detail to the
561 // C++ protected/private protection mechanism!
562}
563
564
565// Assertions
566
567
568template<class T>
569inline
571{
572 if (!ptr_)
573 throw_null_ptr_error(typeName(*this));
574 return *this;
575}
576
577
578template<class T>
579inline
581{
582 if (ptr_)
583 node_.assert_valid_ptr(*this);
584 return *this;
585}
586
587
588// boost::shared_ptr compatiblity funtions
589
590
591template<class T>
592inline
594{
595#ifdef TEUCHOS_DEBUG
596 node_ = RCPNodeHandle();
597#else
598 RCPNodeHandle().swap(node_);
599#endif
600 ptr_ = 0;
601}
602
603
604template<class T>
605template<class T2>
606inline
608{
609 *this = rcp(p, has_ownership_in);
610}
611
612} // end namespace Teuchos
613
614
615// /////////////////////////////////////////////////////////////////////////////////
616// Inline non-member functions for RCP
617
619template<class T>
620inline
622Teuchos::rcp( T* p, bool owns_mem )
623{
624 return RCP<T>(p, owns_mem);
625}
626
627
628template<class T, class Dealloc_T>
629inline
631Teuchos::rcpWithDealloc( T* p, Dealloc_T dealloc, bool owns_mem )
632{
633 return RCP<T>(p, dealloc, owns_mem);
634}
635
636
637template<class T, class Dealloc_T>
638inline
640Teuchos::rcpWithDeallocUndef( T* p, Dealloc_T dealloc, bool owns_mem )
641{
642 return RCP<T>(p, dealloc, RCP_UNDEFINED_WITH_DEALLOC, owns_mem);
643}
644
646template<class T>
648Teuchos::rcpFromRef( T& r )
649{
650 return RCP<T>(&r, RCP_WEAK_NO_DEALLOC);
652
653
654template<class T>
656Teuchos::rcpFromUndefRef( T& r )
658 return RCP<T>(&r, RCP_UNDEFINED_WEAK_NO_DEALLOC);
659}
661
662template<class T, class Embedded>
664Teuchos::rcpWithEmbeddedObjPreDestroy(
665 T* p, const Embedded &embedded, bool owns_mem
667{
668 return rcpWithDealloc(
670 );
671}
672
673
674template<class T, class Embedded>
676Teuchos::rcpWithEmbeddedObjPostDestroy(
677 T* p, const Embedded &embedded, bool owns_mem
678 )
679{
680 return rcpWithDealloc( p, embeddedObjDeallocDelete<T>(embedded,POST_DESTROY), owns_mem );
681}
682
683
684template<class T, class Embedded>
686Teuchos::rcpWithEmbeddedObj( T* p, const Embedded &embedded, bool owns_mem )
687{
689}
690
691
692template<class T, class ParentT>
694Teuchos::rcpWithInvertedObjOwnership(const RCP<T> &child,
695 const RCP<ParentT> &parent)
697 using std::make_pair;
698 return rcpWithEmbeddedObj(child.getRawPtr(), make_pair(child, parent), false);
699}
700
701
702template<class T>
704Teuchos::rcpCloneNode(const RCP<T> &p)
705{
706 if (is_null(p)) {
707 return p;
708 }
709 return rcpWithEmbeddedObj(&*p, p, false);
711
712
713template<class T>
714inline
715bool Teuchos::is_null( const RCP<T> &p )
716{
717 return p.is_null();
718}
719
720
721template<class T>
722inline
723bool Teuchos::nonnull( const RCP<T> &p )
724{
725 return !p.is_null();
726}
727
728
729template<class T>
730inline
731bool Teuchos::operator==( const RCP<T> &p, ENull )
732{
733 return p.get() == NULL;
734}
735
736
737template<class T>
738inline
739bool Teuchos::operator!=( const RCP<T> &p, ENull )
740{
741 return p.get() != NULL;
742}
743
744
745template<class T1, class T2>
746inline
747bool Teuchos::operator==( const RCP<T1> &p1, const RCP<T2> &p2 )
748{
749 return p1.access_private_node().same_node(p2.access_private_node());
750}
751
752
753template<class T1, class T2>
754inline
755bool Teuchos::operator!=( const RCP<T1> &p1, const RCP<T2> &p2 )
756{
757 return !p1.access_private_node().same_node(p2.access_private_node());
758}
759
760
761template<class T2, class T1>
762inline
764Teuchos::rcp_implicit_cast(const RCP<T1>& p1)
765{
766 // Make the compiler check if the conversion is legal
767 T2 *check = p1.get();
768 return RCP<T2>(check, p1.access_private_node());
769}
770
771
772template<class T2, class T1>
773inline
775Teuchos::rcp_static_cast(const RCP<T1>& p1)
776{
777 // Make the compiler check if the conversion is legal
778 T2 *check = static_cast<T2*>(p1.get());
779 return RCP<T2>(check, p1.access_private_node());
780}
781
782
783template<class T2, class T1>
784inline
786Teuchos::rcp_const_cast(const RCP<T1>& p1)
787{
788 // Make the compiler check if the conversion is legal
789 T2 *check = const_cast<T2*>(p1.get());
790 return RCP<T2>(check, p1.access_private_node());
791}
792
793
794template<class T2, class T1>
795inline
797Teuchos::rcp_dynamic_cast(const RCP<T1>& p1, bool throw_on_fail)
798{
799 if (!is_null(p1)) {
800 T2 *p = NULL;
801 if (throw_on_fail) {
802 p = &dyn_cast<T2>(*p1);
803 }
804 else {
805 // Make the compiler check if the conversion is legal
806 p = dynamic_cast<T2*>(p1.get());
807 }
808 if (p) {
809 return RCP<T2>(p, p1.access_private_node());
810 }
811 }
812 return null;
813}
815
816template<class T1, class T2>
817inline
818void Teuchos::set_extra_data( const T1 &extra_data, const std::string& name,
819 const Ptr<RCP<T2> > &p, EPrePostDestruction destroy_when, bool force_unique )
820{
822 p->nonconst_access_private_node().set_extra_data(
823 any(extra_data), name, destroy_when,
824 force_unique );
825}
826
827
828template<class T1, class T2>
829inline
830const T1& Teuchos::get_extra_data( const RCP<T2>& p, const std::string& name )
831{
833 return any_cast<T1>(
834 p.access_private_node().get_extra_data(
836 )
837 );
838}
840
841template<class T1, class T2>
842inline
843T1& Teuchos::get_nonconst_extra_data( RCP<T2>& p, const std::string& name )
844{
846 return any_cast<T1>(
847 p.nonconst_access_private_node().get_extra_data(
849 )
850 );
851}
852
853
854template<class T1, class T2>
855inline
857Teuchos::get_optional_extra_data( const RCP<T2>& p, const std::string& name )
858{
860 const any *extra_data = p.access_private_node().get_optional_extra_data(
862 if (extra_data)
863 return Ptr<const T1>(&any_cast<T1>(*extra_data));
864 return null;
865}
866
867
868template<class T1, class T2>
869inline
871Teuchos::get_optional_nonconst_extra_data( RCP<T2>& p, const std::string& name )
872{
873 p.assert_not_null();
874 any *extra_data = p.nonconst_access_private_node().get_optional_extra_data(
875 TypeNameTraits<T1>::name(), name);
876 if (extra_data)
877 return Ptr<T1>(&any_cast<T1>(*extra_data));
878 return null;
879}
880
881
882template<class Dealloc_T, class T>
883inline
884const Dealloc_T& Teuchos::get_dealloc( const RCP<T>& p )
885{
886 return get_nonconst_dealloc<Dealloc_T>(const_cast<RCP<T>&>(p));
887}
888
890template<class Dealloc_T, class T>
891inline
892Dealloc_T& Teuchos::get_nonconst_dealloc( const RCP<T>& p )
893{
898 p.access_private_node().node_ptr());
901 ,"get_dealloc<" << TypeNameTraits<Dealloc_T>::name()
902 << "," << TypeNameTraits<T>::name() << ">(p): "
903 << "Error, requested type \'" << TypeNameTraits<requested_type>::name()
904 << "\' does not match actual type of the node \'"
905 << typeName(*p.access_private_node().node_ptr()) << "!"
906 );
907 return dnode->get_nonconst_dealloc();
908}
909
910
911template<class Dealloc_T, class T>
912inline
914Teuchos::get_optional_nonconst_dealloc( const RCP<T>& p )
915{
918 RCPNT *dnode = dynamic_cast<RCPNT*>(p.access_private_node().node_ptr());
919 if(dnode)
920 return ptr(&dnode->get_nonconst_dealloc());
921 return null;
922}
923
924
925template<class Dealloc_T, class T>
926inline
928Teuchos::get_optional_dealloc( const RCP<T>& p )
931}
932
933
934template<class TOrig, class Embedded, class T>
935const Embedded& Teuchos::getEmbeddedObj( const RCP<T>& p )
936{
938 return get_dealloc<Dealloc_t>(p).getObj();
939}
940
941
942template<class TOrig, class Embedded, class T>
943Embedded& Teuchos::getNonconstEmbeddedObj( const RCP<T>& p )
944{
946 return get_nonconst_dealloc<Dealloc_t>(p).getNonconstObj();
947}
948
949
950template<class TOrig, class Embedded, class T>
952Teuchos::getOptionalEmbeddedObj( const RCP<T>& p )
953{
954 typedef EmbeddedObjDealloc<TOrig,Embedded,DeallocDelete<TOrig> > Dealloc_t;
955 const Ptr<const Dealloc_t> dealloc = get_optional_dealloc<Dealloc_t>(p);
956 if (!is_null(dealloc)) {
957 return ptr(&dealloc->getObj());
958 }
959 return null;
960}
961
962
963template<class TOrig, class Embedded, class T>
965Teuchos::getOptionalNonconstEmbeddedObj( const RCP<T>& p )
966{
967 typedef EmbeddedObjDealloc<TOrig,Embedded,DeallocDelete<TOrig> > Dealloc_t;
968 const Ptr<Dealloc_t> dealloc = get_optional_nonconst_dealloc<Dealloc_t>(p);
969 if (!is_null(dealloc)) {
970 return ptr(&dealloc->getNonconstObj());
971 }
972 return null;
973}
974
975
976template<class ParentT, class T>
978Teuchos::getInvertedObjOwnershipParent(const RCP<T> &invertedChild)
979{
980 typedef std::pair<RCP<T>, RCP<ParentT> > Pair_t;
981 Pair_t pair = getEmbeddedObj<T, Pair_t>(invertedChild);
982 return pair.second;
983}
984
985
986template<class T>
987std::ostream& Teuchos::operator<<( std::ostream& out, const RCP<T>& p )
988{
989 out
990 << typeName(p) << "{"
991 << "ptr="<<(const void*)(p.get()) // I can't find any alternative to this C cast :-(
992 <<",node="<<p.access_private_node()
993 <<",strong_count="<<p.strong_count()
994 <<",weak_count="<<p.weak_count()
995 <<"}";
996 return out;
997}
998
999
1000#endif // TEUCHOS_RCP_HPP
Reference-counted pointer class and non-member templated function implementations.
Defines basic traits returning the name of a type in a portable and readable way.
Provides std::map class for deficient platforms.
Null reference error exception class.
Simple wrapper class for raw pointers to single objects where no persisting relationship exists.
Handle class that manages the RCPNode's reference counting.
RCPNodeHandle create_strong() const
Return a strong handle.
RCPNodeHandle create_weak() const
Return a weak handle.
int total_count() const
The sum of the weak and string counts.
RCPNodeHandle create_strong_lock() const
Return a strong handle if possible using thread safe atomics.
void assert_valid_ptr(const RCPType &rcp_obj) const
ERCPStrength strength() const
The strength of this handle.
void swap(RCPNodeHandle &node_ref)
Swap the contents of node_ref with *this.
int weak_count() const
The weak count for this RCPNode, or 0 if the node is NULL.
void has_ownership(bool has_ownership_in)
bool is_valid_ptr() const
Whether the underlying pointer is valid.
int strong_count() const
The strong count for this RCPNode, or 0 if the node is NULL.
bool same_node(const RCPNodeHandle &node2) const
Whether the RCPNode for which node2 is a handle is the same RCPNode as this object's RCPNode.
Deletes a (non-owning) RCPNode but not it's underlying object in case of a throw.
static RCPNode * getExistingRCPNode(T *p)
Return a raw pointer to an existing owning RCPNode given the address to the underlying object if it e...
Node class to keep track of address and the reference count for a reference-counted utility class and...
Smart reference counting pointer class for automatic garbage collection.
RCP< const T > getConst() const
Return an RCP<const T> version of *this.
RCP< T > create_weak() const
Create a new weak RCP object from another (strong) RCP object.
Ptr< T > release()
Release the ownership of the underlying dynamically allocated object.
void reset()
Reset to null.
void set_has_ownership()
Give this and other RCP<> objects ownership of the referenced object this->get().
~RCP()
Removes a reference to a dynamically allocated object and possibly deletes the object if owned.
const RCP< T > & assert_valid_ptr() const
If the object pointer is non-null, assert that it is still valid.
bool shares_resource(const RCP< T2 > &r_ptr) const
Returns true if the smart pointers share the same underlying reference-counted object.
Dealloc_T & get_nonconst_dealloc(const RCP< T > &p)
Return a non-const reference to the underlying deallocator object.
void swap(RCP< T > &r_ptr)
Swap the contents with some other RCP object.
RCP(ENull null_arg=null)
Initialize RCP<T> to NULL.
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.
bool is_null() const
Returns true if the underlying pointer is null.
T * getRawPtr() const
Get the raw C++ pointer to the underlying object.
Ptr< T > ptr() const
Get a safer wrapper raw C++ pointer to the underlying object.
const RCP< T > & assert_not_null() const
Throws NullReferenceError if this->get()==NULL, otherwise returns reference to *this.
const RCP< T > & debug_assert_valid_ptr() const
Calls assert_valid_ptr() in a debug build.
Ptr< const T1 > get_optional_extra_data(const RCP< T2 > &p, const std::string &name)
Get a pointer to const extra data (if it exists) associated with a RCP object.
T * operator->() const
Pointer (->) access to members of underlying object.
bool is_valid_ptr() const
Return if the underlying object pointer is still valid or not.
const T1 & get_extra_data(const RCP< T2 > &p, const std::string &name)
Get a const reference to extra data associated with a RCP object.
RCP< T > create_strong() const
Create a new strong RCP object from another (weak) RCP object.
bool has_ownership() const
Returns true if this has ownership of object pointed to by this->get() in order to delete it.
T * get() const
Get the raw C++ pointer to the underlying object.
ERCPStrength strength() const
Strength of the pointer.
void set_extra_data(const T1 &extra_data, const std::string &name, const Ptr< RCP< T2 > > &p, EPrePostDestruction destroy_when=POST_DESTROY, bool force_unique=true)
Set extra data associated with a RCP object.
int weak_count() const
Return the number of active RCP<> objects that have a "weak" reference to the underlying reference-co...
ENull
Used to initialize a RCP object to NULL using an implicit conversion!
const RCP< T > & debug_assert_not_null() const
Calls assert_not_null() in a debug build.
RCP< T > & operator=(const RCP< T > &r_ptr)
Copy the pointer to the referenced object and increment the reference count.
int total_count() const
Total count (strong_count() + weak_count()).
int strong_count() const
Return the number of active RCP<> objects that have a "strong" reference to the underlying reference-...
Ptr< T > operator()() const
Shorthand for ptr().
T & operator*() const
Dereference the underlying object.
Default traits class that just returns typeid(T).name().
Modified boost::any class, which is a container for a templated value.
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
bool is_null(const boost::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.
bool nonnull(const std::shared_ptr< T > &p)
Returns true if p.get()!=NULL.
std::string typeName(const T &t)
Template function for returning the concrete type name of a passed-in object.
std::string concreteTypeName(const T &t)
Template function for returning the type name of the actual concrete name of a passed-in object.
ERCPStrength
Used to specify if the pointer is weak or strong.
EPrePostDestruction
Used to specify a pre or post destruction of extra data.
The Teuchos namespace contains all of the classes, structs and enums used by Teuchos,...
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
RCP< ParentT > getInvertedObjOwnershipParent(const RCP< T > &invertedChild)
Get the parent back from an inverted ownership RCP.