42#ifndef TEUCHOS_ARRAY_RCP_HPP
43#define TEUCHOS_ARRAY_RCP_HPP
59template<
class T>
inline
68template<
class T,
class Dealloc_T>
71 T* p, Dealloc_T dealloc,
bool has_ownership_in
78template<
class T2,
class T1>
106 for (itr_t itr = arcp2.
begin(); itr != arcp2.
end(); ++itr) {
117template<
class T>
inline
119 : ptr_(NULL), lowerOffset_(0), upperOffset_(-1)
122template<
class T>
inline
124 : ptr_(NULL), lowerOffset_(0), upperOffset_(-1)
128template<
class T>
inline
130 : ptr_(0), lowerOffset_(0), upperOffset_(-1)
133 std::fill_n(
begin(), n, val);
136template<
class T>
inline
138 : ptr_(0), lowerOffset_(0), upperOffset_(-1)
143 *
this = arcp_const_cast<const T> (nonconstArray);
147template<
class T>
inline
156 lowerOffset_(lowerOffset_in),
157 upperOffset_(size_in + lowerOffset_in - 1)
165 if (existing_RCPNode) {
181 (void) rcpNodeLookup;
185template<
class T>
inline
193 lowerOffset_(lowerOffset_in),
194 upperOffset_(size_in + lowerOffset_in - 1)
202 if (existing_RCPNode) {
218 (void) rcpNodeLookup;
224template<
class Dealloc_T>
228 Dealloc_T dealloc,
bool has_ownership_in
234 lowerOffset_(lowerOffset_in),
235 upperOffset_(size_in + lowerOffset_in - 1)
250template<
class Dealloc_T>
254 Dealloc_T dealloc,
bool has_ownership_in
260 lowerOffset_(lowerOffset_in),
261 upperOffset_(size_in + lowerOffset_in - 1)
276template<
class T>
inline
280 lowerOffset_(r_ptr.lowerOffset_),
281 upperOffset_(r_ptr.upperOffset_)
284template<
class T>
inline
288 lowerOffset_(r_ptr.lowerOffset_),
289 upperOffset_(r_ptr.upperOffset_)
293template<
class T>
inline
296template<
class T>
inline
300template<
class T>
inline
305 node_ = r_ptr.access_private_node();
314template<
class T>
inline
318 if (
this == &r_ptr) {
321 node_ = r_ptr.access_private_node ();
334template<
class T>
inline
339template<
class T>
inline
345template<
class T>
inline
348 debug_assert_valid_ptr();
349 debug_assert_in_range(0,1);
353template<
class T>
inline
356 debug_assert_valid_ptr();
357 debug_assert_in_range(0,1);
362template<
class T>
inline
365 debug_assert_valid_ptr();
366 debug_assert_in_range(0,1);
370template<
class T>
inline
373 debug_assert_valid_ptr();
374 debug_assert_in_range(0,1);
379template<
class T>
inline
383 debug_assert_valid_ptr();
384 debug_assert_in_range(0,1);
389template<
class T>
inline
393 debug_assert_valid_ptr();
394 debug_assert_in_range(0,1);
400template<
class T>
inline
405template<
class T>
inline
411template<
class T>
inline
414 debug_assert_valid_ptr();
415 debug_assert_in_range(offset,1);
419template<
class T>
inline
422 debug_assert_valid_ptr();
423 debug_assert_in_range(offset,1);
431template<
class T>
inline
434 debug_assert_valid_ptr();
441template<
class T>
inline
444 debug_assert_valid_ptr();
452template<
class T>
inline
455 debug_assert_valid_ptr();
461template<
class T>
inline
464 debug_assert_valid_ptr();
471template<
class T>
inline
474 debug_assert_valid_ptr();
481template<
class T>
inline
484 debug_assert_valid_ptr();
492template<
class T>
inline
495 debug_assert_valid_ptr();
501template<
class T>
inline
504 debug_assert_valid_ptr();
511template<
class T>
inline
514 debug_assert_valid_ptr();
516 lowerOffset_ -= offset;
517 upperOffset_ -= offset;
521template<
class T>
inline
524 debug_assert_valid_ptr();
526 lowerOffset_ -= offset;
527 upperOffset_ -= offset;
532template<
class T>
inline
535 debug_assert_valid_ptr();
537 lowerOffset_ += offset;
538 upperOffset_ += offset;
542template<
class T>
inline
545 debug_assert_valid_ptr();
547 lowerOffset_ += offset;
548 upperOffset_ += offset;
553template<
class T>
inline
561template<
class T>
inline
570template<
class T>
inline
578template<
class T>
inline
590template<
class T>
inline
593 debug_assert_valid_ptr();
594#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
601template<
class T>
inline
604 debug_assert_valid_ptr();
605#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
613template<
class T>
inline
616 debug_assert_valid_ptr();
617#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
618 return *
this + (upperOffset_ + 1);
620 return ptr_ + (upperOffset_ + 1);
624template<
class T>
inline
627 debug_assert_valid_ptr();
628#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
629 return *
this + (upperOffset_ + 1);
631 return ptr_ + (upperOffset_ + 1);
639template<
class T>
inline
643 debug_assert_valid_ptr();
644 const T *cptr = ptr_;
650template<
class T>
inline
657template<
class T>
inline
664 debug_assert_valid_ptr();
665 debug_assert_in_range(lowerOffset_in, size_in);
667 ptr.
ptr_ = ptr.
ptr_ + lowerOffset_in;
673template<
class T>
inline
680 debug_assert_valid_ptr();
681 debug_assert_in_range(lowerOffset_in, size_in);
683 ptr.
ptr_ = ptr.
ptr_ + lowerOffset_in;
693template<
class T>
inline
697 debug_assert_valid_ptr();
701template<
class T>
inline
705 debug_assert_valid_ptr();
710template<
class T>
inline
714 debug_assert_valid_ptr();
718template<
class T>
inline
722 debug_assert_valid_ptr();
727template<
class T>
inline
731 debug_assert_valid_ptr();
732 return upperOffset_ - lowerOffset_ + 1;
735template<
class T>
inline
739 debug_assert_valid_ptr();
740 return upperOffset_ - lowerOffset_ + 1;
747template<
class T>
inline
753 debug_assert_valid_ptr();
754 debug_assert_in_range(lowerOffset_in,size_in);
755#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
756 return ArrayView<T>(persistingView(lowerOffset_in, size_in).create_weak());
758 return arrayView(ptr_ + lowerOffset_in, size_in);
763template<
class T>
inline
770 debug_assert_valid_ptr();
771 debug_assert_in_range(lowerOffset_in,size_in);
772#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
775 return arrayView(ptr_ + lowerOffset_in, size_in);
781template<
class T>
inline
784 return view(lowerOffset_in, size_in);
787template<
class T>
inline
791 return view (lowerOffset_in, size_in);
795template<
class T>
inline
799 return view(lowerOffset_, size());
804template<
class T>
inline
808 return view(lowerOffset_, size());
817template<
class T>
inline
838template<
class T>
inline
841 std::fill_n (this->begin (), n, val);
849 const size_type new_n = std::distance (first, last);
850 if (new_n != size ()) {
851 *
this = arcp<T> (new_n);
853 std::copy (first, last, begin ());
857template<
class T>
inline
871 const size_type small_n = std::min(n, orig_n);
880template<
class T>
inline
890 const size_type orig_n = size ();
892 ArrayRCP<const T> tmp = *
this;
896 ArrayRCP<T> nonconstThis = arcp<T> (n);
897 const size_type small_n = std::min (n, orig_n);
898 for (size_type i = 0; i < small_n; ++i) {
899 nonconstThis[i] = tmp[i];
901 for (size_type i = orig_n; i <
n; ++i) {
902 nonconstThis[i] = val;
904 *
this = arcp_const_cast<const T> (nonconstThis);
910template<
class T>
inline
915template<
class T>
inline
924template<
class T>
inline
927 if (av.
size() == 0) {
938template<
class T>
inline
940 return node_.strength();
943template<
class T>
inline
945 return node_.strength();
949template<
class T>
inline
953 return node_.is_valid_ptr();
957template<
class T>
inline
961 return node_.is_valid_ptr();
966template<
class T>
inline
969 return node_.strong_count();
972template<
class T>
inline
975 return node_.strong_count();
979template<
class T>
inline
982 return node_.weak_count();
985template<
class T>
inline
988 return node_.weak_count();
992template<
class T>
inline
995 return node_.total_count();
998template<
class T>
inline
1001 return node_.total_count();
1005template<
class T>
inline
1008 node_.has_ownership(
true);
1011template<
class T>
inline
1014 node_.has_ownership(
true);
1018template<
class T>
inline
1021 return node_.has_ownership();
1024template<
class T>
inline
1027 return node_.has_ownership();
1031template<
class T>
inline
1034 debug_assert_valid_ptr();
1035 node_.has_ownership(
false);
1039template<
class T>
inline
1042 debug_assert_valid_ptr();
1043 node_.has_ownership(
false);
1048template<
class T>
inline
1050 debug_assert_valid_ptr ();
1051 return ArrayRCP<T> (ptr_, lowerOffset_, size (), node_.create_weak ());
1054template<
class T>
inline
1056 debug_assert_valid_ptr ();
1061template<
class T>
inline
1063 debug_assert_valid_ptr ();
1064 return ArrayRCP<T> (ptr_, lowerOffset_, size (), node_.create_strong ());
1067template<
class T>
inline
1069 debug_assert_valid_ptr ();
1079 return node_.same_node (r_ptr.access_private_node ());
1090 return node_.same_node (r_ptr.access_private_node ());
1100template<
class T>
inline
1105 throw_null_ptr_error(
typeName(*
this));
1109template<
class T>
inline
1114 throw_null_ptr_error (
typeName (*
this));
1120template<
class T>
inline
1124 node_.assert_valid_ptr (*
this);
1129template<
class T>
inline
1133 node_.assert_valid_ptr (*
this);
1139template<
class T>
inline
1146 (lowerOffset_ <= lowerOffset_in && lowerOffset_in+size_in-1 <= upperOffset_)
1151 typeName(*
this)<<
"::assert_in_range:"
1152 " Error, [lowerOffset,lowerOffset+size-1] = ["
1153 <<lowerOffset_in<<
","<<(lowerOffset_in+size_in-1)<<
"] does not lie in the"
1154 " range ["<<lowerOffset_<<
","<<upperOffset_<<
"]!"
1159template<
class T>
inline
1167 (lowerOffset_ <= lowerOffset_in && lowerOffset_in+size_in-1 <= upperOffset_)
1172 typeName (*
this) <<
"::assert_in_range:"
1173 " Error, [lowerOffset,lowerOffset+size-1] = ["
1174 <<lowerOffset_in<<
","<<(lowerOffset_in+size_in-1)<<
"] does not lie in the"
1175 " range ["<<lowerOffset_<<
","<<upperOffset_<<
"]!"
1184template<
class T>
inline
1191 lowerOffset_(lowerOffset_in),
1192 upperOffset_(size_in + lowerOffset_in - 1)
1195template<
class T>
inline
1202 lowerOffset_(lowerOffset_in),
1203 upperOffset_(size_in + lowerOffset_in - 1)
1207template<
class T>
inline
1213template<
class T>
inline
1214const T* ArrayRCP<const T>::access_private_ptr ()
const
1220template<
class T>
inline
1221RCPNodeHandle& ArrayRCP<T>::nonconst_access_private_node()
1226template<
class T>
inline
1227RCPNodeHandle& ArrayRCP<const T>::nonconst_access_private_node()
1233template<
class T>
inline
1234const RCPNodeHandle& ArrayRCP<T>::access_private_node()
const
1239template<
class T>
inline
1240const RCPNodeHandle& ArrayRCP<const T>::access_private_node()
const
1269namespace Utilities {
1270template<
class T1,
class T2>
1275#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
1278 "Error, these iterators are *not* pointing to the same valid memory!"
1286template<
class T>
inline
1289T* p,
typename ArrayRCP<T>::size_type lowerOffset
1290 ,
typename ArrayRCP<T>::size_type size_in
1294 return ArrayRCP<T>(p, lowerOffset, size_in, owns_mem);
1298template<
class T,
class Dealloc_T>
1302T* p,
typename ArrayRCP<T>::size_type lowerOffset
1303 ,
typename ArrayRCP<T>::size_type size_in
1304 ,Dealloc_T dealloc,
bool owns_mem
1307 return ArrayRCP<T>(p, lowerOffset, size_in, dealloc, owns_mem);
1311template<
class T>
inline
1313Teuchos::arcp(
typename ArrayRCP<T>::size_type size )
1321 return ArrayRCP<T>(
new T[size], 0, size,
true);
1325template<
class T>
inline
1327Teuchos::arcpCloneNode(
const ArrayRCP<T> &a)
1332 return arcpWithEmbeddedObj(a.getRawPtr(), a.lowerOffset(), a.size(),
1337template<
class T>
inline
1339Teuchos::arcpClone(
const ArrayView<const T> &v )
1341 const ArrayRCP<T> new_arcp = arcp<T>(v.size());
1342 std::copy( v.begin(), v.end(), new_arcp.begin() );
1347template<
class T,
class Embedded>
1349Teuchos::arcpWithEmbeddedObjPreDestroy(
1351 typename ArrayRCP<T>::size_type lowerOffset,
1352 typename ArrayRCP<T>::size_type size,
1353 const Embedded &embedded,
1358 p, lowerOffset, size,
1359 embeddedObjDeallocArrayDelete<T>(embedded, PRE_DESTROY),
1365template<
class T,
class Embedded>
1367Teuchos::arcpWithEmbeddedObjPostDestroy(
1369 typename ArrayRCP<T>::size_type lowerOffset,
1370 typename ArrayRCP<T>::size_type size,
1371 const Embedded &embedded,
1376 p, lowerOffset, size,
1377 embeddedObjDeallocArrayDelete<T>(embedded, POST_DESTROY),
1383template<
class T,
class Embedded>
1385Teuchos::arcpWithEmbeddedObj(
1387 typename ArrayRCP<T>::size_type lowerOffset,
1388 typename ArrayRCP<T>::size_type size,
1389 const Embedded &embedded,
1393 return arcpWithEmbeddedObjPostDestroy<T,Embedded>(
1394 p, lowerOffset, size, embedded, owns_mem );
1398template<
class T>
inline
1400Teuchos::arcp(
const RCP<std::vector<T> > &v )
1402 if (
is_null(v) || !v->size() )
1404 return arcpWithEmbeddedObjPostDestroy<T,RCP<std::vector<T> > >(
1405 &(*v)[0], 0, v->size(),
1411template<
class T>
inline
1413Teuchos::arcp(
const RCP<
const std::vector<T> > &v )
1415 if (
is_null(v) || !v->size() )
1417 return arcpWithEmbeddedObjPostDestroy<const T,RCP<const std::vector<T> > >(
1418 &(*v)[0], 0, v->size(),
1424template<
class T>
inline
1426Teuchos::arcpFromArrayView(
const ArrayView<T> &av)
1428#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
1429 return av.access_private_arcp();
1431 return arcp(av.getRawPtr(), 0, av.size(),
false);
1436template<
class T>
inline
1438Teuchos::get_std_vector(
const ArrayRCP<T> &ptr )
1440 return getEmbeddedObj<T, RCP<std::vector<T> > >(ptr);
1444template<
class T>
inline
1446Teuchos::get_std_vector(
const ArrayRCP<const T> &ptr )
1448 return getEmbeddedObj<const T, RCP<const std::vector<T> > >(ptr);
1452template<
class T>
inline
1459template<
class T>
inline
1462 return !p.is_null();
1466template<
class T>
inline
1473template<
class T>
inline
1474bool Teuchos::operator!=(
const ArrayRCP<T> &p, ENull )
1476 return !p.is_null();
1480template<
class T1,
class T2>
1484 return p1.access_private_ptr() == p2.access_private_ptr();
1488template<
class T1,
class T2>
1490bool Teuchos::operator!=(
const ArrayRCP<T1> &p1,
const ArrayRCP<T2> &p2 )
1492 return p1.access_private_ptr() != p2.access_private_ptr();
1496template<
class T1,
class T2>
1500 return p1.access_private_ptr() < p2.access_private_ptr();
1504template<
class T1,
class T2>
1508 Utilities::assert_shares_resource(p1,p2);
1509 return p1.access_private_ptr() <= p2.access_private_ptr();
1513template<
class T1,
class T2>
1517 Utilities::assert_shares_resource(p1,p2);
1518 return p1.access_private_ptr() > p2.access_private_ptr();
1522template<
class T1,
class T2>
1526 Utilities::assert_shares_resource(p1,p2);
1527 return p1.access_private_ptr() >= p2.access_private_ptr();
1535 Utilities::assert_shares_resource(p1,p2);
1536 return p1.access_private_ptr() - p2.access_private_ptr();
1540template<
class T2,
class T1>
1543Teuchos::arcp_reinterpret_cast(
const ArrayRCP<T1>& p1)
1545 typedef typename ArrayRCP<T1>::size_type size_type;
1546 const int sizeOfT1 =
sizeof(T1);
1547 const int sizeOfT2 =
sizeof(T2);
1548 size_type lowerOffset2 = (p1.lowerOffset()*sizeOfT1) / sizeOfT2;
1549 size_type upperOffset2 = ((p1.upperOffset()+1)*sizeOfT1) / sizeOfT2 - 1;
1550 T2 *ptr2 =
reinterpret_cast<T2*
>(p1.get());
1551 return ArrayRCP<T2>(
1552 ptr2, lowerOffset2, upperOffset2 - lowerOffset2 + 1,
1553 p1.access_private_node()
1559template<
class T2,
class T1>
1561Teuchos::arcp_reinterpret_cast_nonpod(
const ArrayRCP<T1>& p1,
const T2& val)
1563 typedef typename ArrayRCP<T2>::iterator itr_t;
1564 ArrayRCP<T2> arcp2 = arcp_reinterpret_cast<T2>(p1);
1565 for (itr_t itr = arcp2.begin(); itr != arcp2.end(); ++itr) {
1566 new (&*itr) T2(val);
1568 return arcpWithEmbeddedObj(
1569 arcp2.getRawPtr(), 0, arcp2.size(),
1570 ArcpReinterpretCastEmbeddedObj<T2, T1>(p1),
1578template<
class T2,
class T1>
1581Teuchos::arcp_const_cast(
const ArrayRCP<T1>& p1)
1583 T2 *ptr2 =
const_cast<T2*
>(p1.get());
1584 return ArrayRCP<T2>(
1585 ptr2, p1.lowerOffset(), p1.size(),
1586 p1.access_private_node()
1592template<
class T2,
class T1>
1595Teuchos::arcp_implicit_cast(
const ArrayRCP<T1>& p1)
1597 T2 * raw_ptr2 = p1.
get();
1598 return ArrayRCP<T2>(
1599 raw_ptr2, p1.lowerOffset(), p1.size(),
1600 p1.access_private_node()
1606template<
class T1,
class T2>
1608void Teuchos::set_extra_data(
1609 const T1 &extra_data,
const std::string& name,
1610 const Ptr<ArrayRCP<T2> > &p, EPrePostDestruction destroy_when,
1614 p->assert_not_null();
1615 p->nonconst_access_private_node().set_extra_data( any(extra_data), name, destroy_when,
1620template<
class T1,
class T2>
1622T1& Teuchos::get_extra_data( ArrayRCP<T2>& p,
const std::string& name )
1624 p.assert_not_null();
1625 return any_cast<T1>(
1626 p.nonconst_access_private_node().get_extra_data(
1627 TypeNameTraits<T1>::name(), name
1633template<
class T1,
class T2>
1635const T1& Teuchos::get_extra_data(
const ArrayRCP<T2>& p,
const std::string& name )
1637 p.assert_not_null();
1638 return any_cast<T1>(
1639 p.access_private_node().get_extra_data(
1640 TypeNameTraits<T1>::name() ,name
1646template<
class T1,
class T2>
1648T1* Teuchos::get_optional_extra_data( ArrayRCP<T2>& p,
const std::string& name )
1650 p.assert_not_null();
1651 any *extra_data = p.nonconst_access_private_node().get_optional_extra_data(
1652 TypeNameTraits<T1>::name(), name);
1653 if( extra_data )
return &any_cast<T1>(*extra_data);
1658template<
class T1,
class T2>
1660const T1* Teuchos::get_optional_extra_data(
const ArrayRCP<T2>& p,
const std::string& name )
1662 p.assert_not_null();
1663 any *extra_data = p.access_private_node().get_optional_extra_data(
1664 TypeNameTraits<T1>::name(), name);
1665 if( extra_data )
return &any_cast<T1>(*extra_data);
1670template<
class Dealloc_T,
class T>
1673Teuchos::get_dealloc(
const ArrayRCP<T>& p )
1675 return get_nonconst_dealloc<Dealloc_T>(p);
1679template<
class Dealloc_T,
class T>
1684 typedef RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T> requested_type;
1686 RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T>
1687 *dnode =
dynamic_cast<RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T>*
>(
1688 p.access_private_node().node_ptr());
1690 dnode==NULL, NullReferenceError
1691 ,
"get_dealloc<" << TypeNameTraits<Dealloc_T>::name()
1692 <<
"," << TypeNameTraits<T>::name() <<
">(p): "
1693 <<
"Error, requested type \'" << TypeNameTraits<requested_type>::name()
1694 <<
"\' does not match actual type of the node \'"
1695 <<
typeName(*p.access_private_node().node_ptr()) <<
"!"
1697 return dnode->get_nonconst_dealloc();
1701template<
class Dealloc_T,
class T>
1704Teuchos::get_optional_dealloc(
const ArrayRCP<T>& p )
1706 return get_optional_dealloc<Dealloc_T>(p);
1710template<
class Dealloc_T,
class T>
1716 typedef RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T>
1718 RCPNT *dnode =
dynamic_cast<RCPNT*
>(p.access_private_node().node_ptr());
1720 return &dnode->get_nonconst_dealloc();
1725template<
class TOrig,
class Embedded,
class T>
1726const Embedded& Teuchos::getEmbeddedObj(
const ArrayRCP<T>& p )
1728 typedef EmbeddedObjDealloc<TOrig,Embedded,DeallocArrayDelete<TOrig> > Dealloc_t;
1729 return get_dealloc<Dealloc_t>(p).getObj();
1733template<
class TOrig,
class Embedded,
class T>
1734Embedded& Teuchos::getNonconstEmbeddedObj(
const ArrayRCP<T>& p )
1736 typedef EmbeddedObjDealloc<TOrig,Embedded,DeallocArrayDelete<TOrig> > Dealloc_t;
1737 return get_nonconst_dealloc<Dealloc_t>(p).getNonconstObj();
1750 << TypeNameTraits<ArrayRCP<T> >::name() <<
"{"
1752 if (p.access_private_ptr () == NULL) {
1755 out << (
const void*) (p.access_private_ptr ());
1758 <<
",lowerOffset="<<p.lowerOffset()
1759 <<
",upperOffset="<<p.upperOffset()
1760 <<
",size="<<p.size()
1761 <<
",node=" << p.access_private_node ()
1762 <<
",strong_count="<<p.strong_count()
1763 <<
",weak_count="<<p.weak_count()
Definition of Teuchos::as, for conversions between types.
ArcpReinterpretCastEmbeddedObj(const ArrayRCP< T1 > &arcp_pod)
~ArcpReinterpretCastEmbeddedObj()
ArcpReinterpretCastEmbeddedObj()
ArcpReinterpretCastEmbeddedObj & operator=(const ArcpReinterpretCastEmbeddedObj &arceo)
Reference-counted smart pointer for managing arrays.
ArrayRCP< T > create_weak() const
Create a new weak reference from another (strong) reference.
void set_has_ownership()
Give this and other ArrayRCP<> objects ownership of the underlying referenced array to delete it.
size_type upperOffset() const
Return the upper offset to valid data.
ArrayRCP< T > & operator++()
Prefix increment of pointer (i.e. ++ptr).
Ordinal size_type
Type representing the number of elements in an ArrayRCP or view thereof.
Ordinal difference_type
Type representing the difference between two size_type values.
bool has_ownership() const
Returns true if this has ownership of object pointed to by this->get() in order to deallocate it.
T * iterator
Nonconstant iterator type used if bounds checking is disabled.
ArrayRCP< T > & operator+=(size_type offset)
Pointer integer increment (i.e. ptr+=offset).
ArrayRCP(ENull null_arg=null)
Default constructor; initialize to an empty array.
bool is_null() const
True if the underlying pointer is null, else false.
ArrayRCP< const T > getConst() const
Return object for only const access to data.
size_type upperOffset_
Upper offset to the data; -1 if this array is null.
T & operator*() const
Dereference the underlying object for the current pointer position.
const ArrayRCP< T > & assert_not_null() const
Throws NullReferenceError if this->get()==NULL, otherwise returns reference to *this.
T * release()
Release the ownership of the underlying array.
void clear()
Resize to zero.
T * get() const
Get the raw C++ pointer to the underlying object.
size_type size() const
The total number of entries in the array.
T & operator[](size_type offset) const
Random object access.
ArrayRCP< T > create_strong() const
Create a new strong RCP object from another (weak) RCP object.
void deepCopy(const ArrayView< const T > &av)
Deep copy the elements from one ArrayView object into this object.
bool shares_resource(const ArrayRCP< T2 > &r_ptr) const
Returns true if the smart pointers share the same underlying reference-counted object.
size_type lowerOffset() const
Return the lower offset to valid data.
ArrayRCP< T > operator-(size_type offset) const
Pointer integer decrement (i.e. ptr-offset).
T * getRawPtr() const
Get the raw C++ pointer to the underlying object.
ArrayRCP< T > & operator--()
Prefix decrement of pointer (i.e. –ptr).
ArrayView< T > operator()() const
Return a nonpersisting view of *this.
ArrayView< T > view(size_type lowerOffset, size_type size) const
Return a nonpersisting view of a contiguous range of elements.
const ArrayRCP< T > & assert_in_range(size_type lowerOffset, size_type size) const
Throws NullReferenceError if this->get()==NULL orthis->get()!=NULL, throws RangeError if (lowerOffset...
int strong_count() const
Return the number of active RCP<> objects that have a "strong" reference to the underlying reference-...
ArrayRCP< T > persistingView(size_type lowerOffset, size_type size) const
Return a persisting view of a contiguous range of elements.
RCPNodeHandle node_
Reference-counting machinery.
T * ptr_
Raw pointer to the array; NULL if this array is null.
bool is_valid_ptr() const
Return whether the underlying object pointer is still valid.
void resize(const size_type n, const T &val=T())
Resize and append new elements if necessary.
ArrayRCP< T > & operator=(const ArrayRCP< T > &r_ptr)
Assignment operator: Makes *this reference the input array.
ArrayRCP< T > operator+(size_type offset) const
Pointer integer increment (i.e. ptr+offset).
void assign(size_type n, const T &val)
Resize and assign n elements of val.
iterator begin() const
Return an iterator to beginning of the array of data.
T * operator->() const
Pointer (->) access to members of underlying object for current position.
size_type lowerOffset_
Lower offset to the data; 0 if this array is null.
~ArrayRCP()
Destructor, that decrements the reference count.
ERCPStrength strength() const
Strength of the pointer.
iterator end() const
Return an iterator to past the end of the array of data.
const ArrayRCP< T > & assert_valid_ptr() const
If the object pointer is non-null, assert that it is still valid.
ArrayRCP< T > & operator-=(size_type offset)
Pointer integer increment (i.e. ptr-=offset).
int weak_count() const
Return the number of active RCP<> objects that have a "weak" reference to the underlying reference-co...
int total_count() const
Total count (strong_count() + weak_count()).
iterator end() const
Return an iterator to past the end of the array of data.
iterator begin() const
Return an iterator to beginning of the array of data.
size_type size() const
The total number of items in the managed array.
Deallocator class that uses delete [] to delete memory allocated uisng new []
Incompatiable iterators error exception class.
Handle class that manages the RCPNode's reference counting.
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...
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.
Range error exception class.
#define TEUCHOS_TEST_FOR_EXCEPT(throw_exception_test)
This macro is designed to be a short version of TEUCHOS_TEST_FOR_EXCEPTION() that is easier to call.
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
#define TEUCHOS_ASSERT_INEQUALITY(val1, comp, val2)
This macro is checks that an inequality between two numbers is satisified and if not then throws a go...
#define TEUCHOS_ASSERT_EQUALITY(val1, val2)
This macro is checks that to numbers are equal and if not then throws an exception with a good error ...
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.
void assert_shares_resource(const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2)
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.
bool operator>=(BigUInt< n > const &a, BigUInt< n > const &b)
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)
bool operator<(BigUInt< n > const &a, BigUInt< n > const &b)
ERCPNodeLookup
Used to determine if RCPNode lookup is performed or not.
RCPNode * ArrayRCP_createNewDeallocRCPNodeRawPtr(T *p, Dealloc_T dealloc, bool has_ownership_in)
BigUInt< n > operator-(BigUInt< n > const &a, BigUInt< n > const &b)
bool operator<=(BigUInt< n > const &a, BigUInt< n > const &b)
RCPNode * ArrayRCP_createNewRCPNodeRawPtr(T *p, bool has_ownership_in)
bool operator==(BigUInt< n > const &a, BigUInt< n > const &b)
bool operator>(BigUInt< n > const &a, BigUInt< n > const &b)