42 #ifndef TEUCHOS_ARRAY_RCP_HPP 43 #define TEUCHOS_ARRAY_RCP_HPP 59 template<
class T>
inline 68 template<
class T,
class Dealloc_T>
71 T* p, Dealloc_T dealloc,
bool has_ownership_in
78 template<
class T2,
class T1>
106 for (itr_t itr = arcp2.
begin(); itr != arcp2.
end(); ++itr) {
117 template<
class T>
inline 119 : ptr_(NULL), lowerOffset_(0), upperOffset_(-1)
122 template<
class T>
inline 124 : ptr_(NULL), lowerOffset_(0), upperOffset_(-1)
128 template<
class T>
inline 130 : ptr_(0), lowerOffset_(0), upperOffset_(-1)
133 std::fill_n(begin(),
n, val);
136 template<
class T>
inline 138 : ptr_(0), lowerOffset_(0), upperOffset_(-1)
147 template<
class T>
inline 153 #ifndef TEUCHOS_DEBUG
156 lowerOffset_(lowerOffset_in),
157 upperOffset_(size_in + lowerOffset_in - 1)
163 existing_RCPNode = RCPNodeTracer::getExistingRCPNode(p);
165 if (existing_RCPNode) {
180 #else // NOT TEUCHOS_DEBUG 181 (void) rcpNodeLookup;
182 #endif // TEUCHOS_DEBUG 185 template<
class T>
inline 190 #ifndef TEUCHOS_DEBUG
193 lowerOffset_(lowerOffset_in),
194 upperOffset_(size_in + lowerOffset_in - 1)
202 if (existing_RCPNode) {
217 #else // NOT TEUCHOS_DEBUG 218 (void) rcpNodeLookup;
219 #endif // TEUCHOS_DEBUG 224 template<
class Dealloc_T>
228 Dealloc_T dealloc,
bool has_ownership_in
231 #ifndef TEUCHOS_DEBUG
234 lowerOffset_(lowerOffset_in),
235 upperOffset_(size_in + lowerOffset_in - 1)
246 #endif // TEUCHOS_DEBUG 250 template<
class Dealloc_T>
254 Dealloc_T dealloc,
bool has_ownership_in
257 #ifndef TEUCHOS_DEBUG
260 lowerOffset_(lowerOffset_in),
261 upperOffset_(size_in + lowerOffset_in - 1)
272 #endif // TEUCHOS_DEBUG 276 template<
class T>
inline 280 lowerOffset_(r_ptr.lowerOffset_),
281 upperOffset_(r_ptr.upperOffset_)
284 template<
class T>
inline 288 lowerOffset_(r_ptr.lowerOffset_),
289 upperOffset_(r_ptr.upperOffset_)
293 template<
class T>
inline 296 template<
class T>
inline 300 template<
class T>
inline 305 node_ = r_ptr.access_private_node();
314 template<
class T>
inline 318 if (
this == &r_ptr) {
321 node_ = r_ptr.access_private_node ();
334 template<
class T>
inline 339 template<
class T>
inline 345 template<
class T>
inline 348 debug_assert_valid_ptr();
349 debug_assert_in_range(0,1);
353 template<
class T>
inline 362 template<
class T>
inline 365 debug_assert_valid_ptr();
366 debug_assert_in_range(0,1);
370 template<
class T>
inline 379 template<
class T>
inline 383 debug_assert_valid_ptr();
384 debug_assert_in_range(0,1);
389 template<
class T>
inline 400 template<
class T>
inline 405 template<
class T>
inline 411 template<
class T>
inline 414 debug_assert_valid_ptr();
415 debug_assert_in_range(offset,1);
419 template<
class T>
inline 431 template<
class T>
inline 434 debug_assert_valid_ptr();
441 template<
class T>
inline 452 template<
class T>
inline 455 debug_assert_valid_ptr();
461 template<
class T>
inline 471 template<
class T>
inline 474 debug_assert_valid_ptr();
481 template<
class T>
inline 492 template<
class T>
inline 495 debug_assert_valid_ptr();
501 template<
class T>
inline 511 template<
class T>
inline 514 debug_assert_valid_ptr();
516 lowerOffset_ -= offset;
517 upperOffset_ -= offset;
521 template<
class T>
inline 532 template<
class T>
inline 535 debug_assert_valid_ptr();
537 lowerOffset_ += offset;
538 upperOffset_ += offset;
542 template<
class T>
inline 553 template<
class T>
inline 561 template<
class T>
inline 570 template<
class T>
inline 578 template<
class T>
inline 590 template<
class T>
inline 593 debug_assert_valid_ptr();
594 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 601 template<
class T>
inline 605 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 613 template<
class T>
inline 616 debug_assert_valid_ptr();
617 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 618 return *
this + (upperOffset_ + 1);
620 return ptr_ + (upperOffset_ + 1);
624 template<
class T>
inline 628 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 639 template<
class T>
inline 643 debug_assert_valid_ptr();
644 const T *cptr = ptr_;
650 template<
class T>
inline 657 template<
class T>
inline 664 debug_assert_valid_ptr();
665 debug_assert_in_range(lowerOffset_in, size_in);
667 ptr.
ptr_ = ptr.
ptr_ + lowerOffset_in;
673 template<
class T>
inline 683 ptr.
ptr_ = ptr.
ptr_ + lowerOffset_in;
693 template<
class T>
inline 697 debug_assert_valid_ptr();
701 template<
class T>
inline 710 template<
class T>
inline 714 debug_assert_valid_ptr();
718 template<
class T>
inline 727 template<
class T>
inline 731 debug_assert_valid_ptr();
732 return upperOffset_ - lowerOffset_ + 1;
735 template<
class T>
inline 747 template<
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);
763 template<
class T>
inline 772 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 775 return arrayView(
ptr_ + lowerOffset_in, size_in);
781 template<
class T>
inline 784 return view(lowerOffset_in, size_in);
787 template<
class T>
inline 791 return view (lowerOffset_in, size_in);
795 template<
class T>
inline 799 return view(lowerOffset_, size());
804 template<
class T>
inline 817 template<
class T>
inline 838 template<
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 ());
857 template<
class T>
inline 871 const size_type small_n = std::min(
n, orig_n);
880 template<
class T>
inline 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];
902 nonconstThis[i] = val;
910 template<
class T>
inline 915 template<
class T>
inline 924 template<
class T>
inline 927 if (av.
size() == 0) {
938 template<
class T>
inline 940 return node_.strength();
943 template<
class T>
inline 949 template<
class T>
inline 953 return node_.is_valid_ptr();
957 template<
class T>
inline 966 template<
class T>
inline 969 return node_.strong_count();
972 template<
class T>
inline 979 template<
class T>
inline 982 return node_.weak_count();
985 template<
class T>
inline 992 template<
class T>
inline 995 return node_.total_count();
998 template<
class T>
inline 1005 template<
class T>
inline 1008 node_.has_ownership(
true);
1011 template<
class T>
inline 1018 template<
class T>
inline 1021 return node_.has_ownership();
1024 template<
class T>
inline 1031 template<
class T>
inline 1034 debug_assert_valid_ptr();
1035 node_.has_ownership(
false);
1039 template<
class T>
inline 1048 template<
class T>
inline 1050 debug_assert_valid_ptr ();
1051 return ArrayRCP<T> (ptr_, lowerOffset_, size (), node_.create_weak ());
1054 template<
class T>
inline 1061 template<
class T>
inline 1063 debug_assert_valid_ptr ();
1064 return ArrayRCP<T> (ptr_, lowerOffset_, size (), node_.create_strong ());
1067 template<
class T>
inline 1079 return node_.same_node (r_ptr.access_private_node ());
1100 template<
class T>
inline 1105 throw_null_ptr_error(
typeName(*
this));
1109 template<
class T>
inline 1114 throw_null_ptr_error (
typeName (*
this));
1120 template<
class T>
inline 1124 node_.assert_valid_ptr (*
this);
1129 template<
class T>
inline 1139 template<
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_<<
"]!" 1159 template<
class T>
inline 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" 1184 template<
class T>
inline 1186 return node_.count();
1189 template<
class T>
inline 1198 template<
class T>
inline 1205 lowerOffset_(lowerOffset_in),
1206 upperOffset_(size_in + lowerOffset_in - 1)
1209 template<
class T>
inline 1216 lowerOffset_(lowerOffset_in),
1217 upperOffset_(size_in + lowerOffset_in - 1)
1221 template<
class T>
inline 1227 template<
class T>
inline 1228 const T* ArrayRCP<const T>::access_private_ptr ()
const 1234 template<
class T>
inline 1235 RCPNodeHandle& ArrayRCP<T>::nonconst_access_private_node()
1240 template<
class T>
inline 1241 RCPNodeHandle& ArrayRCP<const T>::nonconst_access_private_node()
1247 template<
class T>
inline 1248 const RCPNodeHandle& ArrayRCP<T>::access_private_node()
const 1253 template<
class T>
inline 1254 const RCPNodeHandle& ArrayRCP<const T>::access_private_node()
const 1283 namespace Utilities {
1284 template<
class T1,
class T2>
1289 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 1292 "Error, these iterators are *not* pointing to the same valid memory!" 1300 template<
class T>
inline 1303 T* p,
typename ArrayRCP<T>::size_type lowerOffset
1304 ,
typename ArrayRCP<T>::size_type size_in
1308 return ArrayRCP<T>(p, lowerOffset, size_in, owns_mem);
1312 template<
class T,
class Dealloc_T>
1316 T* p,
typename ArrayRCP<T>::size_type lowerOffset
1317 ,
typename ArrayRCP<T>::size_type size_in
1318 ,Dealloc_T dealloc,
bool owns_mem
1321 return ArrayRCP<T>(p, lowerOffset, size_in, dealloc, owns_mem);
1325 template<
class T>
inline 1327 Teuchos::arcp(
typename ArrayRCP<T>::size_type
size )
1329 #ifdef TEUCHOS_DEBUG 1335 return ArrayRCP<T>(
new T[
size], 0,
size,
true);
1339 template<
class T>
inline 1341 Teuchos::arcpCloneNode(
const ArrayRCP<T> &a)
1351 template<
class T>
inline 1353 Teuchos::arcpClone(
const ArrayView<const T> &v )
1355 const ArrayRCP<T> new_arcp = arcp<T>(v.size());
1356 std::copy( v.begin(), v.end(), new_arcp.begin() );
1361 template<
class T,
class Embedded>
1363 Teuchos::arcpWithEmbeddedObjPreDestroy(
1365 typename ArrayRCP<T>::size_type lowerOffset,
1366 typename ArrayRCP<T>::size_type
size,
1367 const Embedded &embedded,
1372 p, lowerOffset,
size,
1373 embeddedObjDeallocArrayDelete<T>(embedded,
PRE_DESTROY),
1379 template<
class T,
class Embedded>
1381 Teuchos::arcpWithEmbeddedObjPostDestroy(
1383 typename ArrayRCP<T>::size_type lowerOffset,
1384 typename ArrayRCP<T>::size_type
size,
1385 const Embedded &embedded,
1390 p, lowerOffset,
size,
1391 embeddedObjDeallocArrayDelete<T>(embedded,
POST_DESTROY),
1397 template<
class T,
class Embedded>
1399 Teuchos::arcpWithEmbeddedObj(
1401 typename ArrayRCP<T>::size_type lowerOffset,
1402 typename ArrayRCP<T>::size_type
size,
1403 const Embedded &embedded,
1407 return arcpWithEmbeddedObjPostDestroy<T,Embedded>(
1408 p, lowerOffset,
size, embedded, owns_mem );
1412 template<
class T>
inline 1414 Teuchos::arcp(
const RCP<std::vector<T> > &v )
1416 if (
is_null(v) || !v->size() )
1418 return arcpWithEmbeddedObjPostDestroy<T,RCP<std::vector<T> > >(
1419 &(*v)[0], 0, v->size(),
1425 template<
class T>
inline 1427 Teuchos::arcp(
const RCP<
const std::vector<T> > &v )
1429 if (
is_null(v) || !v->size() )
1431 return arcpWithEmbeddedObjPostDestroy<const T,RCP<const std::vector<T> > >(
1432 &(*v)[0], 0, v->size(),
1438 template<
class T>
inline 1440 Teuchos::arcpFromArrayView(
const ArrayView<T> &av)
1442 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK 1443 return av.access_private_arcp();
1445 return arcp(av.getRawPtr(), 0, av.size(),
false);
1450 template<
class T>
inline 1452 Teuchos::get_std_vector(
const ArrayRCP<T> &
ptr )
1454 return getEmbeddedObj<T, RCP<std::vector<T> > >(
ptr);
1458 template<
class T>
inline 1460 Teuchos::get_std_vector(
const ArrayRCP<const T> &
ptr )
1462 return getEmbeddedObj<const T, RCP<const std::vector<T> > >(
ptr);
1466 template<
class T>
inline 1473 template<
class T>
inline 1476 return !p.is_null();
1480 template<
class T>
inline 1487 template<
class T>
inline 1490 return !p.is_null();
1494 template<
class T1,
class T2>
1498 return p1.access_private_ptr() == p2.access_private_ptr();
1502 template<
class T1,
class T2>
1506 return p1.access_private_ptr() != p2.access_private_ptr();
1510 template<
class T1,
class T2>
1512 bool Teuchos::operator<( const ArrayRCP<T1> &p1,
const ArrayRCP<T2> &p2 )
1514 return p1.access_private_ptr() < p2.access_private_ptr();
1518 template<
class T1,
class T2>
1520 bool Teuchos::operator<=( const ArrayRCP<T1> &p1,
const ArrayRCP<T2> &p2 )
1523 return p1.access_private_ptr() <= p2.access_private_ptr();
1527 template<
class T1,
class T2>
1529 bool Teuchos::operator>(
const ArrayRCP<T1> &p1,
const ArrayRCP<T2> &p2 )
1532 return p1.access_private_ptr() > p2.access_private_ptr();
1536 template<
class T1,
class T2>
1538 bool Teuchos::operator>=(
const ArrayRCP<T1> &p1,
const ArrayRCP<T2> &p2 )
1541 return p1.access_private_ptr() >= p2.access_private_ptr();
1547 Teuchos::operator-(
const ArrayRCP<T> &p1,
const ArrayRCP<T> &p2 )
1550 return p1.access_private_ptr() - p2.access_private_ptr();
1554 template<
class T2,
class T1>
1557 Teuchos::arcp_reinterpret_cast(
const ArrayRCP<T1>& p1)
1560 const int sizeOfT1 =
sizeof(T1);
1561 const int sizeOfT2 =
sizeof(T2);
1562 size_type lowerOffset2 = (p1.lowerOffset()*sizeOfT1) / sizeOfT2;
1563 size_type upperOffset2 = ((p1.upperOffset()+1)*sizeOfT1) / sizeOfT2 - 1;
1564 T2 *ptr2 =
reinterpret_cast<T2*
>(p1.get());
1565 return ArrayRCP<T2>(
1566 ptr2, lowerOffset2, upperOffset2 - lowerOffset2 + 1,
1567 p1.access_private_node()
1573 template<
class T2,
class T1>
1575 Teuchos::arcp_reinterpret_cast_nonpod(
const ArrayRCP<T1>& p1,
const T2& val)
1577 typedef typename ArrayRCP<T2>::iterator itr_t;
1579 for (itr_t itr = arcp2.begin(); itr != arcp2.end(); ++itr) {
1580 new (&*itr) T2(val);
1583 arcp2.getRawPtr(), 0, arcp2.size(),
1584 ArcpReinterpretCastEmbeddedObj<T2, T1>(p1),
1592 template<
class T2,
class T1>
1595 Teuchos::arcp_const_cast(
const ArrayRCP<T1>& p1)
1597 T2 *ptr2 =
const_cast<T2*
>(p1.get());
1598 return ArrayRCP<T2>(
1599 ptr2, p1.lowerOffset(), p1.size(),
1600 p1.access_private_node()
1606 template<
class T2,
class T1>
1609 Teuchos::arcp_implicit_cast(
const ArrayRCP<T1>& p1)
1611 T2 * raw_ptr2 = p1.
get();
1612 return ArrayRCP<T2>(
1613 raw_ptr2, p1.lowerOffset(), p1.size(),
1614 p1.access_private_node()
1620 template<
class T1,
class T2>
1622 void Teuchos::set_extra_data(
1623 const T1 &extra_data,
const std::string& name,
1628 p->assert_not_null();
1629 p->nonconst_access_private_node().set_extra_data( any(extra_data), name, destroy_when,
1634 template<
class T1,
class T2>
1636 T1& Teuchos::get_extra_data( ArrayRCP<T2>& p,
const std::string& name )
1638 p.assert_not_null();
1640 p.nonconst_access_private_node().get_extra_data(
1641 TypeNameTraits<T1>::name(), name
1647 template<
class T1,
class T2>
1649 const T1& Teuchos::get_extra_data(
const ArrayRCP<T2>& p,
const std::string& name )
1651 p.assert_not_null();
1653 p.access_private_node().get_extra_data(
1654 TypeNameTraits<T1>::name() ,name
1660 template<
class T1,
class T2>
1662 T1* Teuchos::get_optional_extra_data( ArrayRCP<T2>& p,
const std::string& name )
1664 p.assert_not_null();
1665 any *extra_data = p.nonconst_access_private_node().get_optional_extra_data(
1666 TypeNameTraits<T1>::name(), name);
1667 if( extra_data )
return &
any_cast<T1>(*extra_data);
1672 template<
class T1,
class T2>
1674 const T1* Teuchos::get_optional_extra_data(
const ArrayRCP<T2>& p,
const std::string& name )
1676 p.assert_not_null();
1677 any *extra_data = p.access_private_node().get_optional_extra_data(
1678 TypeNameTraits<T1>::name(), name);
1679 if( extra_data )
return &
any_cast<T1>(*extra_data);
1684 template<
class Dealloc_T,
class T>
1687 Teuchos::get_dealloc(
const ArrayRCP<T>& p )
1689 return get_nonconst_dealloc<Dealloc_T>(p);
1693 template<
class Dealloc_T,
class T>
1698 typedef RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T> requested_type;
1700 RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T>
1701 *dnode =
dynamic_cast<RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T>*
>(
1702 p.access_private_node().node_ptr());
1704 dnode==NULL, NullReferenceError
1705 ,
"get_dealloc<" << TypeNameTraits<Dealloc_T>::name()
1706 <<
"," << TypeNameTraits<T>::name() <<
">(p): " 1707 <<
"Error, requested type \'" << TypeNameTraits<requested_type>::name()
1708 <<
"\' does not match actual type of the node \'" 1709 <<
typeName(*p.access_private_node().node_ptr()) <<
"!" 1711 return dnode->get_nonconst_dealloc();
1715 template<
class Dealloc_T,
class T>
1718 Teuchos::get_optional_dealloc(
const ArrayRCP<T>& p )
1720 return get_optional_dealloc<Dealloc_T>(p);
1724 template<
class Dealloc_T,
class T>
1730 typedef RCPNodeTmpl<typename Dealloc_T::ptr_t,Dealloc_T>
1732 RCPNT *dnode =
dynamic_cast<RCPNT*
>(p.access_private_node().node_ptr());
1734 return &dnode->get_nonconst_dealloc();
1739 template<
class TOrig,
class Embedded,
class T>
1740 const Embedded& Teuchos::getEmbeddedObj(
const ArrayRCP<T>& p )
1742 typedef EmbeddedObjDealloc<TOrig,Embedded,DeallocArrayDelete<TOrig> > Dealloc_t;
1743 return get_dealloc<Dealloc_t>(p).getObj();
1747 template<
class TOrig,
class Embedded,
class T>
1748 Embedded& Teuchos::getNonconstEmbeddedObj(
const ArrayRCP<T>& p )
1750 typedef EmbeddedObjDealloc<TOrig,Embedded,DeallocArrayDelete<TOrig> > Dealloc_t;
1751 return get_nonconst_dealloc<Dealloc_t>(p).getNonconstObj();
1756 std::ostream& Teuchos::operator<<( std::ostream& out, const ArrayRCP<T>& p )
1764 << TypeNameTraits<ArrayRCP<T> >::name() <<
"{" 1766 if (p.access_private_ptr () == NULL) {
1769 out << (
const void*) (p.access_private_ptr ());
1774 <<
",size="<<p.
size()
1775 <<
",node=" << p.access_private_node ()
1787 #endif // TEUCHOS_ARRAY_RCP_HPP T * get() const
Get the raw C++ pointer to the underlying object.
ArrayRCP< T > create_weak() const
Create a new weak reference from another (strong) reference.
size_type lowerOffset_
Lower offset to the data; 0 if this array is null.
ERCPStrength
Used to specify if the pointer is weak or strong.
ArcpReinterpretCastEmbeddedObj & operator=(const ArcpReinterpretCastEmbeddedObj &arceo)
ArrayRCP< T > operator+(size_type offset) const
Pointer integer increment (i.e. ptr+offset).
std::string typeName(const T &t)
Template function for returning the concrete type name of a passed-in object.
ArrayRCP(ENull null_arg=null)
Default constructor; initialize to an empty array.
RCPNode * ArrayRCP_createNewDeallocRCPNodeRawPtr(T *p, Dealloc_T dealloc, bool has_ownership_in)
Partial specialization of ArrayRCP for const T.
void assert_valid_ptr(const RCPType &rcp_obj) const
Ordinal difference_type
Type representing the difference between two size_type values.
size_type size() const
The total number of entries in the array.
ArrayRCP< T > & operator++()
Prefix increment of pointer (i.e. ++ptr).
ArrayRCP< T > & operator+=(size_type offset)
Pointer integer increment (i.e. ptr+=offset).
T & operator[](size_type offset) const
Random object access.
bool nonnull(const std::shared_ptr< T > &p)
Returns true if p.get()!=NULL.
ArcpReinterpretCastEmbeddedObj()
bool is_null(const std::shared_ptr< T > &p)
Returns true if p.get()==NULL.
#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...
ValueType & any_cast(any &operand)
Used to extract the templated value held in Teuchos::any to a given value type.
ArrayRCP< T > & operator-=(size_type offset)
Pointer integer increment (i.e. ptr-=offset).
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Macro for throwing an exception with breakpointing to ease debugging.
int strong_count() const
Return the number of active RCP<> objects that have a "strong" reference to the underlying reference-...
int count() const
The strong count; retained for backwards compatibility.
ArrayRCP< T > & operator--()
Prefix decrement of pointer (i.e. –ptr).
T * release()
Release the ownership of the underlying array.
ERCPNodeLookup
Used to determine if RCPNode lookup is performed or not.
const ArrayRCP< T > & assert_not_null() const
Throws NullReferenceError if this->get()==NULL, otherwise returns reference to *this.
ArrayRCP< T > arcp(const RCP< Array< T > > &v)
Wrap an RCP<Array<T> > object as an ArrayRCP<T> object.
void release()
Releaes the RCPNode pointer before the destructor is called.
ENull
Used to initialize a RCP object to NULL using an implicit conversion!
void clear()
Resize to zero.
TEUCHOS_DEPRECATED int count() const
Returns strong_count() [deprecated].
Ordinal size_type
Type representing the number of elements in an ArrayRCP or view thereof.
~ArrayRCP()
Destructor, that decrements the reference count.
RCPNodeHandle create_strong() const
Return a strong handle.
bool is_null(const ArrayRCP< T > &p)
Returns true if p.get()==NULL.
RCPNodeHandle node_
Reference-counting machinery.
void debug_assert_in_range(size_type lowerOffset_in, size_type size_in) const
bool operator!=(const Allocator< T > &a_t, const Allocator< U > &a_u)
Return ! (a_t == a_u) (see above).
ArrayRCP< T2 > arcp_reinterpret_cast(const ArrayRCP< T1 > &p1)
Reinterpret cast of underlying ArrayRCP type from T1* to T2*.
const ArrayRCP< T > & assert_valid_ptr() const
If the object pointer is non-null, assert that it is still valid.
void resize(const size_type n, const T &val=T())
Resize and append new elements if necessary.
void debug_assert_valid_ptr() const
Node class to keep track of address and the reference count for a reference-counted utility class and...
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...
Deallocator class that uses delete [] to delete memory allocated uisng new []
bool has_ownership() const
Returns true if this has ownership of object pointed to by this->get() in order to deallocate it...
Templated implementation class of RCPNode that has the responsibility for deleting the reference-coun...
bool shares_resource(const ArrayRCP< T2 > &r_ptr) const
Returns true if the smart pointers share the same underlying reference-counted object.
ArrayRCP< const T > getConst() const
Return object for only const access to data.
ArrayRCP< T > persistingView(size_type lowerOffset, size_type size) const
Return a persisting view of a contiguous range of elements.
std::string concreteTypeName(const T &t)
Template function for returning the type name of the actual concrete name of a passed-in object...
int total_count() const
Total count (strong_count() + weak_count()).
bool is_valid_ptr() const
Return whether the underlying object pointer is still valid.
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...
void deepCopy(const ArrayView< const T > &av)
Deep copy the elements from one ArrayView object into this object.
size_type upperOffset() const
Return the upper offset to valid data.
int size(const Comm< Ordinal > &comm)
Get the number of processes in the communicator.
ArrayRCP< T > create_strong() const
Create a new strong RCP object from another (weak) RCP object.
iterator end() const
Return an iterator to past the end of the array of data.
Incompatiable iterators error exception class.
int weak_count() const
The weak count for this RCPNode, or 0 if the node is NULL.
static RCPNode * getExistingRCPNode(T *p)
Return a raw pointer to an existing owning RCPNode given the address to the underlying object if it e...
Ptr< T > ptr(T *p)
Create a pointer to an object from a raw pointer.
T * ptr_
Raw pointer to the array; NULL if this array is null.
int weak_count() const
Return the number of active RCP<> objects that have a "weak" reference to the underlying reference-co...
iterator begin() const
Return an iterator to beginning of the array of data.
ERCPStrength strength() const
Strength of the pointer.
bool is_null() const
True if the underlying pointer is null, else false.
bool operator==(const TwoDArray< T > &a1, const TwoDArray< T > &a2)
void set_has_ownership()
Give this and other ArrayRCP<> objects ownership of the underlying referenced array to delete it...
ERCPStrength strength() const
The strength of this handle.
EPrePostDestruction
Used to specify a pre or post destruction of extra data.
bool is_valid_ptr() const
Whether the underlying pointer is valid.
Handle class that manages the RCPNode's reference counting.
int strong_count() const
The strong count for this RCPNode, or 0 if the node is NULL.
void has_ownership(bool has_ownership_in)
ArrayView< T > view(size_type lowerOffset, size_type size) const
Return a nonpersisting view of a contiguous range of elements.
T & operator*() const
Dereference the underlying object for the current pointer position.
ArrayRCP< T > arcpWithEmbeddedObj(T *p, typename ArrayRCP< T >::size_type lowerOffset, typename ArrayRCP< T >::size_type size, const Embedded &embedded, bool owns_mem=true)
Create an ArrayRCP with and also put in an embedded object.
ArrayRCP< T2 > arcp_const_cast(const ArrayRCP< T1 > &p1)
Const cast of underlying ArrayRCP type from const T* to T*.
RCPNodeHandle create_weak() const
Return a weak handle.
ArrayRCP< T > & operator=(const ArrayRCP< T > &r_ptr)
Assignment operator: Makes *this reference the input array.
void assert_shares_resource(const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2)
ArcpReinterpretCastEmbeddedObj(const ArrayRCP< T1 > &arcp_pod)
Smart reference counting pointer class for automatic garbage collection.
T * getRawPtr() const
Get the raw C++ pointer to the underlying object.
ArrayRCP< T > operator-(size_type offset) const
Pointer integer decrement (i.e. ptr-offset).
Deletes a (non-owning) RCPNode but not it's underlying object in case of a throw. ...
T * iterator
Nonconstant iterator type used if bounds checking is disabled.
Partial specialization of ArrayView for const T.
RCPNode * ArrayRCP_createNewRCPNodeRawPtr(T *p, bool has_ownership_in)
Range error exception class.
#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 ...
size_type upperOffset_
Upper offset to the data; -1 if this array is null.
size_type lowerOffset() const
Return the lower offset to valid data.
~ArcpReinterpretCastEmbeddedObj()
Definition of Teuchos::as, for conversions between types.
int total_count() const
The sum of the weak and string counts.
#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...
void assign(size_type n, const T &val)
Resize and assign n elements of val.
ArrayView< T > operator()() const
Return a nonpersisting view of *this.
T * operator->() const
Pointer (->) access to members of underlying object for current position.