Teuchos Package Browser (Single Doxygen Collection) 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"
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
76{
77 return new RCPNodeTmpl<T,DeallocNull<T> >(p, DeallocNull<T>(), false);
78}
79
80
81template<class T>
82inline
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
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
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
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
157 : ptr_(p)
158#ifndef TEUCHOS_DEBUG
160#endif // TEUCHOS_DEBUG
161{
162#ifdef TEUCHOS_DEBUG
163 if (p) {
164 RCPNode* existing_RCPNode = RCPNodeTracer::getExistingRCPNode(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(...)
173 p, typeName(*p), concreteTypeName(*p),
174 false
175 );
176 }
177 }
178#endif // TEUCHOS_DEBUG
179}
180
181
182template<class T>
183inline
185 : ptr_(p),
187{}
188
189
190template<class T>
191inline
192RCP<T>::RCP( T* p, bool has_ownership_in )
193 : ptr_(p)
194#ifndef TEUCHOS_DEBUG
195 , node_(RCP_createNewRCPNodeRawPtr(p, has_ownership_in))
196#endif // TEUCHOS_DEBUG
197{
198#ifdef TEUCHOS_DEBUG
199 if (p) {
200 RCPNode* existing_RCPNode = 0;
201 if (!has_ownership_in) {
202 existing_RCPNode = RCPNodeTracer::getExistingRCPNode(p);
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));
212 nodeDeleter.get(),
213 p, typeName(*p), concreteTypeName(*p),
214 has_ownership_in
215 );
216 nodeDeleter.release();
217 }
218 }
219#endif // TEUCHOS_DEBUG
220}
221
222
223template<class T>
224template<class Dealloc_T>
225inline
226RCP<T>::RCP( T* p, Dealloc_T dealloc, bool has_ownership_in )
227 : ptr_(p)
228#ifndef TEUCHOS_DEBUG
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));
239 nodeDeleter.get(),
240 p, typeName(*p), concreteTypeName(*p),
241 has_ownership_in
242 );
243 nodeDeleter.release();
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)
254#ifndef TEUCHOS_DEBUG
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
265 p, dealloc, has_ownership_in));
267 nodeDeleter.get(),
268 p, typeName(*p), concreteTypeName(*p),
269 has_ownership_in
270 );
271 nodeDeleter.release();
272 }
273#endif // TEUCHOS_DEBUG
274}
275
276
277template<class T>
278inline
279RCP<T>::RCP(const RCP<T>& r_ptr)
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
296RCP<T>::RCP(const RCP<T2>& r_ptr)
297 : ptr_(r_ptr.get()), // will not compile if T is not base class of T2
298 node_(r_ptr.access_private_node())
299{}
300
301
302template<class T>
303template<class T2>
304inline
305RCP<T>::RCP(const RCP<T2>& r_ptr, T* ptr)
306 : ptr_(ptr),
307 node_(r_ptr.access_private_node())
308{}
309
310
311template<class T>
312inline
314{}
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{
380 debug_assert_not_null();
381 debug_assert_valid_ptr();
382 return ptr_;
383}
384
385
386template<class T>
387inline
389{
390 debug_assert_not_null();
391 debug_assert_valid_ptr();
392 return *ptr_;
393}
394
395template<class T>
396inline
397T* RCP<T>::get() const
398{
399 debug_assert_valid_ptr();
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{
513 debug_assert_valid_ptr();
514 node_.has_ownership(false);
515 return Ptr<T>(ptr_);
516}
517
518
519template<class T>
520inline
523 debug_assert_valid_ptr();
524 return RCP<T>(ptr_, node_.create_weak());
525}
526
527
528template<class T>
529inline
532 debug_assert_valid_ptr();
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
547 RCPNodeHandle attemptStrong = node_.create_strong_lock();
548 return RCP<T>( attemptStrong.is_node_null() ? 0 : ptr_, attemptStrong);
549}
550#endif
551
552
553template<class T>
554template <class T2>
555inline
556bool RCP<T>::shares_resource(const RCP<T2>& r_ptr) const
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
607void RCP<T>::reset(T2* p, bool has_ownership_in)
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 )
659}
661
662template<class T, class Embedded>
664Teuchos::rcpWithEmbeddedObjPreDestroy(
665 T* p, const Embedded &embedded, bool owns_mem
667{
668 return rcpWithDealloc(
669 p, embeddedObjDeallocDelete<T>(embedded,PRE_DESTROY), owns_mem
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{
688 return rcpWithEmbeddedObjPostDestroy<T,Embedded>(p,embedded,owns_mem);
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{
821 p->assert_not_null();
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{
832 p.assert_not_null();
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{
845 p.assert_not_null();
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{
859 p.assert_not_null();
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{
895 p.assert_not_null();
898 p.access_private_node().node_ptr());
900 dnode==NULL, NullReferenceError
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{
916 p.assert_not_null();
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 )
930 return get_optional_nonconst_dealloc<Dealloc_T>(const_cast<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.
Policy class for deallocator that uses delete to delete a pointer which is used by RCP.
Policy class for deallocator for non-owned RCPs.
A deallocator class that wraps a simple value object and delegates to another deallocator object.
const Embedded & getObj() const
Null reference error exception class.
Simple wrapper class for raw pointers to single objects where no persisting relationship exists.
const Ptr< T > & assert_not_null() const
Throws std::logic_error if this->get()==NULL, otherwise returns reference to *this.
Handle class that manages the RCPNode's reference counting.
RCPNodeHandle create_strong_lock() const
Return a strong handle if possible using thread safe atomics.
bool is_node_null() const
Whether the underlying RCPNode is NULL.
void swap(RCPNodeHandle &node_ref)
Swap the contents of node_ref with *this.
Deletes a (non-owning) RCPNode but not it's underlying object in case of a throw.
void release()
Releaes the RCPNode pointer before the destructor is called.
Templated implementation class of RCPNode that has the responsibility for deleting the reference-coun...
Dealloc_T & get_nonconst_dealloc()
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.
RCPNodeHandle node_
bool shares_resource(const RCP< T2 > &r_ptr) const
Returns true if the smart pointers share the same underlying reference-counted 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.
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.
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.
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!
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.
ERCPStrength
Used to specify if the pointer is weak or strong.
std::string typeName(const T &t)
Template function for returning the concrete type name of a passed-in object.
RCPNode * RCP_createNewRCPNodeRawPtr(T *p, bool has_ownership_in)
Definition: Teuchos_RCP.hpp:91
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Deprecated.
std::string concreteTypeName(const T &t)
Template function for returning the type name of the actual concrete name of a passed-in object.
std::ostream & operator<<(std::ostream &os, BigUInt< n > a)
RCPNode * RCP_createNewDeallocRCPNodeRawPtrUndefined(T *p, Dealloc_T dealloc, bool has_ownership_in)
RawPointerConversionTraits< Container >::Ptr_t getRawPtr(const Container &c)
ERCPUndefinedWeakNoDealloc
@ RCP_UNDEFINED_WEAK_NO_DEALLOC
RCPNode * RCP_createNewDeallocRCPNodeRawPtr(T *p, Dealloc_T dealloc, bool has_ownership_in)
Definition: Teuchos_RCP.hpp:99
RCPNode * RCP_createNewRCPNodeRawPtrNonownedUndefined(T *p)
Definition: Teuchos_RCP.hpp:83
EPrePostDestruction
Used to specify a pre or post destruction of extra data.
RCPNode * RCP_createNewRCPNodeRawPtrNonowned(T *p)
Definition: Teuchos_RCP.hpp:75
@ RCP_UNDEFINED_WITH_DEALLOC
bool operator==(BigUInt< n > const &a, BigUInt< n > const &b)
RCP< ParentT > getInvertedObjOwnershipParent(const RCP< T > &invertedChild)
Get the parent back from an inverted ownership RCP.