|
Teuchos - Trilinos Tools Package
Version of the Day
|
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
|
Teuchos - Trilinos Tools Package
Version of the Day
|
Reference-counted smart pointer for managing arrays. More...
#include <Teuchos_ArrayRCPDecl.hpp>
Public Types | |
Public typedefs | |
| typedef Teuchos_Ordinal | Ordinal |
| Integer index type used throughout ArrayRCP. More... | |
| typedef Ordinal | size_type |
| Type representing the number of elements in an ArrayRCP or view thereof. More... | |
| typedef Ordinal | difference_type |
| Type representing the difference between two size_type values. More... | |
| typedef std::random_access_iterator_tag | iterator_category |
| Category of ArrayRCP's iterator type. More... | |
| typedef T * | iterator_type |
| Type of an ArrayRCP's iterator. More... | |
| typedef T | value_type |
| Type of each array element. More... | |
| typedef T & | reference |
| Type of a (nonconstant) reference to an array element. More... | |
| typedef const T & | const_reference |
| Type of a (constant) reference to an array element. More... | |
| typedef T * | pointer |
| Type of a (raw) (nonconstant) pointer to an array element. More... | |
| typedef T * | const_pointer |
| Type of a (raw) (constant) pointer to an array element. More... | |
| typedef T | element_type |
| Type of each array element. More... | |
| typedef T * | iterator |
| Nonconstant iterator type used if bounds checking is disabled. More... | |
| typedef const T * | const_iterator |
| Constant iterator type used if bounds checking is disabled. More... | |
Public Member Functions | |
Constructors/Destructors/Initializers | |
| ArrayRCP (ENull null_arg=null) | |
| Default constructor; initialize to an empty array. More... | |
| ArrayRCP (T *p, size_type lowerOffset, size_type size, bool has_ownership, const ERCPNodeLookup rcpNodeLookup=RCP_ENABLE_NODE_LOOKUP) | |
| Construct from a raw pointer and a valid range. More... | |
| template<class Dealloc_T > | |
| ArrayRCP (T *p, size_type lowerOffset, size_type size, Dealloc_T dealloc, bool has_ownership) | |
| Construct from a raw pointer, a valid range, and a deallocator. More... | |
| ArrayRCP (size_type size, const T &val=T()) | |
| Construct an array with the given number of elements. More... | |
| ArrayRCP (const ArrayRCP< T > &r_ptr) | |
Initialize from another ArrayRCP<T> object. More... | |
| ~ArrayRCP () | |
| Destructor, that decrements the reference count. More... | |
| ArrayRCP< T > & | operator= (const ArrayRCP< T > &r_ptr) |
Assignment operator: Makes *this reference the input array. More... | |
Object/Pointer Access Functions | |
| bool | is_null () const |
| True if the underlying pointer is null, else false. More... | |
| T * | operator-> () const |
Pointer (->) access to members of underlying object for current position. More... | |
| T & | operator* () const |
| Dereference the underlying object for the current pointer position. More... | |
| T * | get () const |
| Get the raw C++ pointer to the underlying object. More... | |
| T * | getRawPtr () const |
| Get the raw C++ pointer to the underlying object. More... | |
| T & | operator[] (size_type offset) const |
| Random object access. More... | |
Pointer Arithmetic Functions | |
| ArrayRCP< T > & | operator++ () |
| Prefix increment of pointer (i.e. ++ptr). More... | |
| ArrayRCP< T > | operator++ (int) |
| Postfix increment of pointer (i.e. ptr++). More... | |
| ArrayRCP< T > & | operator-- () |
| Prefix decrement of pointer (i.e. –ptr). More... | |
| ArrayRCP< T > | operator-- (int) |
| Postfix decrement of pointer (i.e. ptr–). More... | |
| ArrayRCP< T > & | operator+= (size_type offset) |
| Pointer integer increment (i.e. ptr+=offset). More... | |
| ArrayRCP< T > & | operator-= (size_type offset) |
| Pointer integer increment (i.e. ptr-=offset). More... | |
| ArrayRCP< T > | operator+ (size_type offset) const |
| Pointer integer increment (i.e. ptr+offset). More... | |
| ArrayRCP< T > | operator- (size_type offset) const |
| Pointer integer decrement (i.e. ptr-offset). More... | |
Standard Container-Like Functions | |
| iterator | begin () const |
| Return an iterator to beginning of the array of data. More... | |
| iterator | end () const |
| Return an iterator to past the end of the array of data. More... | |
ArrayRCP Views | |
| ArrayRCP< const T > | getConst () const |
| Return object for only const access to data. More... | |
| ArrayRCP< T > | persistingView (size_type lowerOffset, size_type size) const |
| Return a persisting view of a contiguous range of elements. More... | |
Size and extent query functions | |
| size_type | lowerOffset () const |
| Return the lower offset to valid data. More... | |
| size_type | upperOffset () const |
| Return the upper offset to valid data. More... | |
| size_type | size () const |
| The total number of entries in the array. More... | |
ArrayView views | |
| ArrayView< T > | view (size_type lowerOffset, size_type size) const |
| Return a nonpersisting view of a contiguous range of elements. More... | |
| ArrayView< T > | operator() (size_type lowerOffset, size_type size) const |
| Return a nonpersisting view of a contiguous range of elements. More... | |
| ArrayView< T > | operator() () const |
Return a nonpersisting view of *this. More... | |
Implicit conversions | |
| operator ArrayRCP< const T > () const | |
| Convert from ArrayRCP<T> to ArrayRCP<const T>. More... | |
std::vector like and other misc functions | |
| void | assign (size_type n, const T &val) |
| Resize and assign n elements of val. More... | |
| template<class Iter > | |
| void | assign (Iter first, Iter last) |
| Resize and assign to iterator sequence [first, last) More... | |
| void | deepCopy (const ArrayView< const T > &av) |
| Deep copy the elements from one ArrayView object into this object. More... | |
| void | resize (const size_type n, const T &val=T()) |
| Resize and append new elements if necessary. More... | |
| void | clear () |
| Resize to zero. More... | |
Reference counting | |
| ERCPStrength | strength () const |
| Strength of the pointer. More... | |
| bool | is_valid_ptr () const |
| Return whether the underlying object pointer is still valid. More... | |
| int | strong_count () const |
Return the number of active RCP<> objects that have a "strong" reference to the underlying reference-counted object. More... | |
| int | weak_count () const |
Return the number of active RCP<> objects that have a "weak" reference to the underlying reference-counted object. More... | |
| int | total_count () const |
| Total count (strong_count() + weak_count()). More... | |
| void | set_has_ownership () |
Give this and other ArrayRCP<> objects ownership of the underlying referenced array to delete it. More... | |
| bool | has_ownership () const |
Returns true if this has ownership of object pointed to by this->get() in order to deallocate it. More... | |
| T * | release () |
| Release the ownership of the underlying array. More... | |
| ArrayRCP< T > | create_weak () const |
| Create a new weak reference from another (strong) reference. More... | |
| ArrayRCP< T > | create_strong () const |
| Create a new strong RCP object from another (weak) RCP object. More... | |
| template<class T2 > | |
| bool | shares_resource (const ArrayRCP< T2 > &r_ptr) const |
| Returns true if the smart pointers share the same underlying reference-counted object. More... | |
Assertion Functions. | |
| const ArrayRCP< T > & | assert_not_null () const |
Throws NullReferenceError if this->get()==NULL, otherwise returns reference to *this. More... | |
| 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 < this->lowerOffset() || this->upperOffset() < upperOffset, otherwise returns reference to *this More... | |
| const ArrayRCP< T > & | assert_valid_ptr () const |
| If the object pointer is non-null, assert that it is still valid. More... | |
Related Functions | |
(Note that these are not member functions.) | |
| template<class T > | |
| ArrayRCP< T > | arcp (const RCP< Array< T > > &v) |
Wrap an RCP<Array<T> > object as an ArrayRCP<T> object. More... | |
| template<class T > | |
| ArrayRCP< const T > | arcp (const RCP< const Array< T > > &v) |
Wrap a RCP<const Array<T> > object as an ArrayRCP<const T> object. More... | |
| template<class T > | |
| ArrayRCP< T > | arcpFromArray (Array< T > &a) |
Wrap an Array<T> object as a non-owning ArrayRCP<T> object. More... | |
| template<class T > | |
| ArrayRCP< const T > | arcpFromArray (const Array< T > &a) |
Wrap a const Array<T> object as a non-owning ArrayRCP<T> object. More... | |
| template<class T > | |
| ArrayRCP< T > | arcp (T *p, typename ArrayRCP< T >::size_type lowerOffset, typename ArrayRCP< T >::size_type size, bool owns_mem=true) |
| Wraps a preallocated array of data with the assumption to call the array version of delete. More... | |
| template<class T , class Dealloc_T > | |
| ArrayRCP< T > | arcp (T *p, typename ArrayRCP< T >::size_type lowerOffset, typename ArrayRCP< T >::size_type size, Dealloc_T dealloc, bool owns_mem) |
| Wraps a preallocated array of data and uses a templated deallocation strategy object to define deletion . More... | |
| template<class T > | |
| ArrayRCP< T > | arcp (typename ArrayRCP< T >::size_type size) |
| Allocate a new array just given a dimension. More... | |
| template<class T > | |
| ArrayRCP< T > | arcpCloneNode (const ArrayRCP< T > &a) |
| Allocate a new ArrayRCP object with a new RCPNode with memory pointing to the initial node. More... | |
| template<class T > | |
| ArrayRCP< T > | arcpClone (const ArrayView< const T > &v) |
| Allocate a new array by cloning data from an input array view. More... | |
| template<class T , class Embedded > | |
| ArrayRCP< T > | arcpWithEmbeddedObjPreDestroy (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. More... | |
| template<class T , class Embedded > | |
| ArrayRCP< T > | arcpWithEmbeddedObjPostDestroy (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. More... | |
| template<class T , class Embedded > | |
| 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. More... | |
| template<class T > | |
| ArrayRCP< T > | arcp (const RCP< std::vector< T > > &v) |
Wrap an std::vector<T> object as an ArrayRCP<T> object. More... | |
| template<class T > | |
| ArrayRCP< const T > | arcp (const RCP< const std::vector< T > > &v) |
Wrap a const std::vector<T> object as an ArrayRCP<const T> object. More... | |
| template<class T > | |
| ArrayRCP< T > | arcpFromArrayView (const ArrayView< T > &av) |
| Get an ArrayRCP object out of an ArrayView object. More... | |
| template<class T > | |
| RCP< std::vector< T > > | get_std_vector (const ArrayRCP< T > &ptr) |
Get an std::vector<T> object out of an ArrayRCP<T> object that was created using the arcp() function above to wrap the std::vector in the first place.. More... | |
| template<class T > | |
| RCP< const std::vector< T > > | get_std_vector (const ArrayRCP< const T > &ptr) |
Get a const std::vector<T> object out of an ArrayRCP<const T> object that was created using the arcp() above to wrap the std::vector in the first place. More... | |
| template<class T > | |
| bool | is_null (const ArrayRCP< T > &p) |
Returns true if p.get()==NULL. More... | |
| template<class T > | |
| bool | nonnull (const ArrayRCP< T > &p) |
Returns true if p.get()!=NULL. More... | |
| template<class T > | |
| bool | operator== (const ArrayRCP< T > &p, ENull) |
Returns true if p.get()==NULL. More... | |
| template<class T > | |
| bool | operator!= (const ArrayRCP< T > &p, ENull) |
Returns true if p.get()!=NULL. More... | |
| template<class T1 , class T2 > | |
| bool | operator== (const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2) |
| Compare two ArrayRCP objects for equality (by pointers). More... | |
| template<class T1 , class T2 > | |
| bool | operator!= (const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2) |
| Compare two ArrayRCP objects for inequality (by pointers). More... | |
| template<class T1 , class T2 > | |
| bool | operator< (const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2) |
| Compare the two ArrayRCP objects' pointers using <. More... | |
| template<class T1 , class T2 > | |
| bool | operator<= (const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2) |
| Compare the two ArrayRCP objects' pointers using <=. More... | |
| template<class T1 , class T2 > | |
| bool | operator> (const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2) |
| Compare the two ArrayRCP objects' pointers using >. More... | |
| template<class T1 , class T2 > | |
| bool | operator>= (const ArrayRCP< T1 > &p1, const ArrayRCP< T2 > &p2) |
| Compare the two ArrayRCP objects' pointers using >=. More... | |
| template<class T > | |
| ArrayRCP< T >::difference_type | operator- (const ArrayRCP< T > &p1, const ArrayRCP< T > &p2) |
| Return the difference of two ArrayRCP objects. More... | |
| template<class T2 , class T1 > | |
| ArrayRCP< T2 > | arcp_const_cast (const ArrayRCP< T1 > &p1) |
Const cast of underlying ArrayRCP type from const T* to T*. More... | |
| template<class T2 , class T1 > | |
| ArrayRCP< T2 > | arcp_reinterpret_cast (const ArrayRCP< T1 > &p1) |
Reinterpret cast of underlying ArrayRCP type from T1* to T2*. More... | |
| template<class T2 , class T1 > | |
| ArrayRCP< T2 > | arcp_reinterpret_cast_nonpod (const ArrayRCP< T1 > &p1, const T2 &val=T2()) |
Reinterpret cast of underlying ArrayRCP type from T1* to T2* where T2 is a non-POD (non-plain-old-data). More... | |
| template<class T2 , class T1 > | |
| ArrayRCP< T2 > | arcp_implicit_cast (const ArrayRCP< T1 > &p1) |
Implicit case the underlying ArrayRCP type from T1* to T2*. More... | |
| template<class T1 , class T2 > | |
| void | set_extra_data (const T1 &extra_data, const std::string &name, const Ptr< ArrayRCP< T2 > > &p, EPrePostDestruction destroy_when=POST_DESTROY, bool force_unique=true) |
Set extra data associated with a ArrayRCP object. More... | |
| template<class T1 , class T2 > | |
| T1 & | get_extra_data (ArrayRCP< T2 > &p, const std::string &name) |
Get a non-const reference to extra data associated with a ArrayRCP object. More... | |
| template<class T1 , class T2 > | |
| const T1 & | get_extra_data (const ArrayRCP< T2 > &p, const std::string &name) |
Get a const reference to extra data associated with a ArrayRCP object. More... | |
| template<class T1 , class T2 > | |
| T1 * | get_optional_extra_data (ArrayRCP< T2 > &p, const std::string &name) |
Get a pointer to non-const extra data (if it exists) associated with a ArrayRCP object. More... | |
| template<class T1 , class T2 > | |
| const T1 * | get_optional_extra_data (const ArrayRCP< T2 > &p, const std::string &name) |
Get a pointer to const extra data (if it exists) associated with a ArrayRCP object. More... | |
| template<class Dealloc_T , class T > | |
| Dealloc_T & | get_nonconst_dealloc (const ArrayRCP< T > &p) |
Return a non-const reference to the underlying deallocator object. More... | |
| template<class Dealloc_T , class T > | |
| const Dealloc_T & | get_dealloc (const ArrayRCP< T > &p) |
Return a const reference to the underlying deallocator object. More... | |
| template<class Dealloc_T , class T > | |
| const Dealloc_T * | get_optional_dealloc (const ArrayRCP< T > &p) |
Return a pointer to the underlying non-const deallocator object if it exists. More... | |
| template<class Dealloc_T , class T > | |
| Dealloc_T * | get_optional_nonconst_dealloc (const ArrayRCP< T > &p) |
Return a pointer to the underlying const deallocator object if it exists. More... | |
| template<class TOrig , class Embedded , class T > | |
| const Embedded & | getEmbeddedObj (const ArrayRCP< T > &p) |
Get a const reference to an embedded object that was set by calling arcpWithEmbeddedObjPreDestroy(), arcpWithEmbeddedObjPostDestory(), or arcpWithEmbeddedObj(). More... | |
| template<class TOrig , class Embedded , class T > | |
| Embedded & | getNonconstEmbeddedObj (const ArrayRCP< T > &p) |
Get a const reference to an embedded object that was set by calling arcpWithEmbeddedObjPreDestroy(), arcpWithEmbeddedObjPostDestory(), or arcpWithEmbeddedObj(). More... | |
| template<class T > | |
| std::ostream & | operator<< (std::ostream &out, const ArrayRCP< T > &p) |
| Output stream inserter. More... | |
Reference-counted smart pointer for managing arrays.
| T | The type of each element in the array. |
ArrayRCP manages an array of objects of type T. Like RCP, it uses reference counting to decide when to deallocate the array. This lets you share references to the array, without worrying about who is responsible for deallocating it. We may thus call an ArrayRCP a "shared array."
Managing an array of objects is very different from managing a pointer to an individual, possibly polymorphic, object. For example, while implicit conversions from derived to base types can be useful when dealing with pointers to single objects, they often cause problems when working with arrays of objects. Therefore, this class contains those capabilities of raw pointers that are good when working with arrays of objects, but excludes those that are bad, such as implicit conversions from derived to base types. If you really do want a shared array with implicit conversions from derived to base types, you may use an ArrayRCP<RCP<T> >.
You may enable bounds checking and other safety checks for this class by setting the Teuchos_ENABLE_DEBUG:BOOL=ON CMake option when configuring your Trilinos build. This option is off by default. It incurs a significant performance penalty and so is not recommended for production builds. Bounds checking requires that you always create ArrayRCP instances with the correct range. For example, if you use one of the constructors that accepts a raw pointer, you are responsible for supplying the correct number of elements in the array. Our bounds checking implementation does not attempt to replace memory debugging tools such as the Memcheck tool in Valgrind.
ArrayRCP imposes the following requirements on the type T of elements in the array:
This class has a partial specialization for const T that omits the conversion operator operator ArrayRCP<const T>() const, and the assign() and deepCopy() methods (which perform a deep copy). The conversion operator does not make sense if T is already const T' for some type T', and the assign() and deepCopy() methods do not make sense if the right-hand side of the assignment is const.
Partial specialization results in duplicated code, so Teuchos developers should be careful to make modifications in both the fully generic implementation and in the partial specialization.
We considered avoiding most of the duplication by making ArrayRCP<T> and its partial specialization ArrayRCP<const T> inherit from a common base class, which contains all the common code. However, the circular dependency between ArrayRCP and ArrayView would have complicated this solution. We chose instead the simple "partial specialization
without a common base class" solution, which does not interfere with the ArrayRCP / ArrayView circular dependency.
Definition at line 94 of file Teuchos_ArrayRCPDecl.hpp.
| typedef Teuchos_Ordinal Teuchos::ArrayRCP< T >::Ordinal |
Integer index type used throughout ArrayRCP.
Definition at line 100 of file Teuchos_ArrayRCPDecl.hpp.
| typedef Ordinal Teuchos::ArrayRCP< T >::size_type |
Type representing the number of elements in an ArrayRCP or view thereof.
Definition at line 103 of file Teuchos_ArrayRCPDecl.hpp.
| typedef Ordinal Teuchos::ArrayRCP< T >::difference_type |
Type representing the difference between two size_type values.
Definition at line 106 of file Teuchos_ArrayRCPDecl.hpp.
| typedef std::random_access_iterator_tag Teuchos::ArrayRCP< T >::iterator_category |
Category of ArrayRCP's iterator type.
Definition at line 109 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T* Teuchos::ArrayRCP< T >::iterator_type |
Type of an ArrayRCP's iterator.
Definition at line 112 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T Teuchos::ArrayRCP< T >::value_type |
Type of each array element.
Definition at line 115 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T& Teuchos::ArrayRCP< T >::reference |
Type of a (nonconstant) reference to an array element.
Definition at line 118 of file Teuchos_ArrayRCPDecl.hpp.
| typedef const T& Teuchos::ArrayRCP< T >::const_reference |
Type of a (constant) reference to an array element.
Definition at line 121 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T* Teuchos::ArrayRCP< T >::pointer |
Type of a (raw) (nonconstant) pointer to an array element.
Definition at line 124 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T* Teuchos::ArrayRCP< T >::const_pointer |
Type of a (raw) (constant) pointer to an array element.
Definition at line 127 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T Teuchos::ArrayRCP< T >::element_type |
Type of each array element.
Definition at line 130 of file Teuchos_ArrayRCPDecl.hpp.
| typedef T* Teuchos::ArrayRCP< T >::iterator |
Nonconstant iterator type used if bounds checking is disabled.
Definition at line 139 of file Teuchos_ArrayRCPDecl.hpp.
| typedef const T* Teuchos::ArrayRCP< T >::const_iterator |
Constant iterator type used if bounds checking is disabled.
Definition at line 141 of file Teuchos_ArrayRCPDecl.hpp.
|
inline |
Default constructor; initialize to an empty array.
This lets users write code like:
or
Both lines of code above set the raw array pointer to NULL, and the array's length to zero.
Definition at line 86 of file Teuchos_ArrayRCP.hpp.
|
inline |
Construct from a raw pointer and a valid range.
| p | [in] Raw array pointer. |
| lowerOffset | [in] Array index at which the range starts (zero if at the beginning of the range). |
| size | [in] Number of array elements in the range. |
| has_ownership | [in] True if the ArrayRCP is responsible for deallocating the raw array (using delete []) when the reference count goes to zero. If false, the ArrayRCP does not deallocate the array. |
| rcpNodeLookup | [in] Whether to perform RCPNode lookup. The default value is fine for nearly all use cases. |
this->get() == p this->lowerOffset() == lowerOffset this->upperOffset() == size + lowerOffset - 1 this->has_ownership() == has_ownershipDefinition at line 116 of file Teuchos_ArrayRCP.hpp.
|
inline |
Construct from a raw pointer, a valid range, and a deallocator.
| p | [in] Raw array pointer. |
| lowerOffset | [in] Array index at which the range starts (zero if at the beginning of the range). |
| size | [in] Number of array elements in the range. |
| dealloc | [in] Function (or object with an operator()(T*) method) responsible for deallocating the raw array when the reference count goes to zero. |
| has_ownership | [in] True if the ArrayRCP is responsible for deallocating the raw array (using the given deallocator) when the reference count goes to zero. If false, the ArrayRCP does not deallocate the array. |
this->get() == p this->lowerOffset() == lowerOffset this->upperOffset() == size + lowerOffset - 1 this->has_ownership() == has_ownershipDefinition at line 194 of file Teuchos_ArrayRCP.hpp.
|
inlineexplicit |
Construct an array with the given number of elements.
| size | [in] Number of elements in the array. |
| val | [in] Value with which to fill all elements of the array. |
This constructor fills the array as if with the following code:
this->lowerOffset() == 0 this->upperOffset() == size - 1 this->has_ownership() == true Definition at line 97 of file Teuchos_ArrayRCP.hpp.
|
inline |
Initialize from another ArrayRCP<T> object.
After construction, this and r_ptr will reference the same array.
this->get() == r_ptr.get() this->count() == r_ptr.count() this->has_ownership() == r_ptr.has_ownership() r_ptr.get() != NULL then r_ptr.count() is incremented by 1.Definition at line 245 of file Teuchos_ArrayRCP.hpp.
|
inline |
Destructor, that decrements the reference count.
If this->get() == NULL then the destructor does nothing. Otherwise, it decrements the reference count of this and all other references to the array. If the final reference count is zero, it also deallocates the array if owned (i.e., if this->has_ownership() returns true). Deallocation uses the custom deallocator if one was supplied; otherwise it uses delete [].
Definition at line 262 of file Teuchos_ArrayRCP.hpp.
|
inline |
Assignment operator: Makes *this reference the input array.
If the input array is a reference to *this (that is, if this->getRawPtr() == r_ptr.getRawPtr()), then this method does nothing. Otherwise, it does the following:
*this (as if its destructor had been called) *this a reference to the input array (thus incrementing its reference count) For example, after the following sample code is done, the array to which x originally pointed on construction will have reference count 2, and the array to which y originally pointed on constructor will have reference count 0 (and will thus be deallocated).
this->get() == r_ptr.get() this->count() == r_ptr.count() this->has_ownership() == r_ptr.has_ownership() r_ptr.get() != NULL then r_ptr.count() is incremented by 1 Definition at line 269 of file Teuchos_ArrayRCP.hpp.
|
inline |
True if the underlying pointer is null, else false.
Definition at line 303 of file Teuchos_ArrayRCP.hpp.
|
inline |
Pointer (->) access to members of underlying object for current position.
this->get() != NULL this->lowerOffset() <= 0 this->upperOffset() >= 0 Definition at line 314 of file Teuchos_ArrayRCP.hpp.
|
inline |
Dereference the underlying object for the current pointer position.
this->get() != NULL this->lowerOffset() <= 0 this->upperOffset() >= 0 Definition at line 331 of file Teuchos_ArrayRCP.hpp.
|
inline |
Get the raw C++ pointer to the underlying object.
*this != null] this->lowerOffset() <= 0 *this != null] this->upperOffset() >= 0 Definition at line 348 of file Teuchos_ArrayRCP.hpp.
|
inline |
Get the raw C++ pointer to the underlying object.
*this != null] this->lowerOffset() <= 0 *this != null] this->upperOffset() >= 0 Definition at line 369 of file Teuchos_ArrayRCP.hpp.
|
inline |
Random object access.
this->get() != NULL this->lowerOffset() <= offset && offset <= this->upperOffset() Definition at line 380 of file Teuchos_ArrayRCP.hpp.
|
inline |
Prefix increment of pointer (i.e. ++ptr).
Does nothing if this->get() == NULL.
this->get()!=NULL] this->get() is incremented by 1 this->get()!=NULL] this->lowerOffset() is decremented by 1 this->get()!=NULL] this->upperOffset() is decremented by 1 Definition at line 400 of file Teuchos_ArrayRCP.hpp.
|
inline |
Postfix increment of pointer (i.e. ptr++).
Does nothing if this->get() == NULL.
this->get() is incremented by 1 this->lowerOffset() is decremented by 1 this->upperOffset() is decremented by 1 Definition at line 421 of file Teuchos_ArrayRCP.hpp.
|
inline |
Prefix decrement of pointer (i.e. –ptr).
Does nothing if this->get() == NULL.
this->get()!=NULL] this->get() is decremented by 1 this->get()!=NULL] this->lowerOffset() is incremented by 1 this->get()!=NULL] this->upperOffset() is incremented by 1 Definition at line 440 of file Teuchos_ArrayRCP.hpp.
|
inline |
Postfix decrement of pointer (i.e. ptr–).
Does nothing if this->get() == NULL.
this->get() is decremented by 1 this->lowerOffset() is incremented by 1 this->upperOffset() is incremented by 1 Definition at line 461 of file Teuchos_ArrayRCP.hpp.
|
inline |
Pointer integer increment (i.e. ptr+=offset).
Does nothing if this->get() == NULL.
this->get()!=NULL] this->get() is incremented by offset this->get()!=NULL] this->lowerOffset() is decremented by offset this->get()!=NULL] this->upperOffset() is decremented by offset Definition at line 480 of file Teuchos_ArrayRCP.hpp.
|
inline |
Pointer integer increment (i.e. ptr-=offset).
Does nothing if this->get() == NULL.
this->get()!=NULL] this->get() is decremented by offset this->get()!=NULL] this->lowerOffset() is incremented by offset this->get()!=NULL] this->upperOffset() is incremented by offset Definition at line 501 of file Teuchos_ArrayRCP.hpp.
|
inline |
Pointer integer increment (i.e. ptr+offset).
Returns a null pointer if this->get() == NULL.
this->get()!=NULL] return->get() == this->get() + offset this->get()!=NULL] return->lowerOffset() == this->lowerOffset() - offset this->get()!=NULL] return->upperOffset() == this->upperOffset() - offsetNote that since implicit conversion of ArrayRCP<T> objects is not allowed that it does not help at all to make this function into a non-member function.
Definition at line 522 of file Teuchos_ArrayRCP.hpp.
|
inline |
Pointer integer decrement (i.e. ptr-offset).
Returns a null pointer if this->get() == NULL.
this->get()!=NULL] return->get() == this->get() - offset this->get()!=NULL] return->lowerOffset() == this->lowerOffset() + offset this->get()!=NULL] return->upperOffset() == this->upperOffset() + offsetNote that since implicit conversion of ArrayRCP<T> objects is not allowed that it does not help at all to make this function into a non-member function.
Definition at line 539 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return an iterator to beginning of the array of data.
If HAVE_TEUCHOS_ARRAY_BOUNDSCHECK is defined then the iterator returned is an ArrayRCP<T> object and all operations are checked at runtime. When HAVE_TEUCHOS_ARRAY_BOUNDSCHECK is not defined, the a raw pointer T* is returned for fast execution.
this->get()!=NULL] &*return == this->get() this->get()==NULL] return == (null or NULL) Definition at line 559 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return an iterator to past the end of the array of data.
If HAVE_TEUCHOS_ARRAY_BOUNDSCHECK is defined then the iterator returned is an ArrayRCP<T> object and all operations are checked at runtime. When HAVE_TEUCHOS_ARRAY_BOUNDSCHECK is not defined, the a raw pointer T* is returned for fast execution.
this->get()!=NULL] &*end == this->get()+(this->upperOffset()+1) this->get()==NULL] return == (null or NULL) Definition at line 582 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return object for only const access to data.
This function should only compile successfully if the type T is not already declared const!
Definition at line 608 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return a persisting view of a contiguous range of elements.
this->get() != NULL this->lowerOffset() <= lowerOffset lowerOffset + size - 1 <= this->upperOffset()return->get() == this->get() + lowerOffset return->lowerOffset() == 0 return->upperOffset() == size-1size==0 view of even a null ArrayRCP is allowed. It returns a null view in that case. Definition at line 627 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return the lower offset to valid data.
Definition at line 663 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return the upper offset to valid data.
Definition at line 680 of file Teuchos_ArrayRCP.hpp.
|
inline |
The total number of entries in the array.
x.upperOffset() - x.lowerOffset() + 1 == x.size() for any ArrayRCP x.
Definition at line 697 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return a nonpersisting view of a contiguous range of elements.
this->get() != NULL this->lowerOffset() <= lowerOffset lowerOffset + size - 1 <= this->upperOffset()return->get() == this->get() + lowerOffset return->lowerOffset() == 0 return->upperOffset() == size-1size==0 view of even a null ArrayRCP is allowed. It returns a null view in that case. Definition at line 716 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return a nonpersisting view of a contiguous range of elements.
This is equivalent to calling view (offset, size).
Definition at line 750 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return a nonpersisting view of *this.
Definition at line 764 of file Teuchos_ArrayRCP.hpp.
|
inline |
Convert from ArrayRCP<T> to ArrayRCP<const T>.
const T' for some type T'). In that case, the assignment operator and copy constructor achieve the same syntactic effect. Definition at line 786 of file Teuchos_ArrayRCP.hpp.
|
inline |
Resize and assign n elements of val.
size() == n
Definition at line 807 of file Teuchos_ArrayRCP.hpp.
|
inline |
Resize and assign to iterator sequence [first, last)
size() == std::distance(first, last)
This will not change the underlying pointer array if the size does not change.
Definition at line 816 of file Teuchos_ArrayRCP.hpp.
|
inline |
Deep copy the elements from one ArrayView object into this object.
This is equivalent to calling assign (av.begin (), av.end ())
Definition at line 893 of file Teuchos_ArrayRCP.hpp.
|
inline |
Resize and append new elements if necessary.
Definition at line 826 of file Teuchos_ArrayRCP.hpp.
|
inline |
|
inline |
Strength of the pointer.
Return values:
RCP_STRONG: Underlying reference-counted object will be deleted when *this is destroyed if strong_count()==1. RCP_WEAK: Underlying reference-counted object will not be deleted when *this is destroyed if strong_count() > 0. RCP_STRENGTH_INVALID: *this is not strong or weak but is null. Definition at line 907 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return whether the underlying object pointer is still valid.
The underlying object will not be valid if the strong count has gone to zero but the weak count has not.
NOTE: Null is a valid object pointer. If you want to know if there is a non-null object and it is valid then !is_null() && is_valid_ptr() will be true.
Definition at line 918 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return the number of active RCP<> objects that have a "strong" reference to the underlying reference-counted object.
this->get() == NULL then this function returns 0. Definition at line 935 of file Teuchos_ArrayRCP.hpp.
|
inline |
Return the number of active RCP<> objects that have a "weak" reference to the underlying reference-counted object.
this->get() == NULL then this function returns 0. Definition at line 948 of file Teuchos_ArrayRCP.hpp.
|
inline |
Total count (strong_count() + weak_count()).
Definition at line 961 of file Teuchos_ArrayRCP.hpp.
|
inline |
Give this and other ArrayRCP<> objects ownership of the underlying referenced array to delete it.
See ~ArrayRCP() above. This function does nothing if this->get() == NULL.
Postconditions:
this->get() == NULL then this->has_ownership() == false (always!). this->has_ownership() == true Definition at line 974 of file Teuchos_ArrayRCP.hpp.
|
inline |
Returns true if this has ownership of object pointed to by this->get() in order to deallocate it.
See the above documentation for the destructor.
== NULL then this function always returns false. Otherwise the value returned from this function depends on which function was called most recently, if any; set_has_ownership() (true) or release() (false). Definition at line 987 of file Teuchos_ArrayRCP.hpp.
|
inline |
Release the ownership of the underlying array.
After this function is called then the client is responsible for deleting the returned pointer no matter how many ref_count_ptr<T> objects have a reference to it. If this->get() == NULL, then this call is meaningless.
Note that this function does not have the exact same semantics as does auto_ptr<T>::release(). In auto_ptr<T>::release(), this is set to NULL while here in ArrayRCP<T>:: release() only an ownership flag is set and this still points to the same array. It would be difficult to duplicate the behavior of auto_ptr<T>::release() for this class.
Postconditions:
this->has_ownership() == false this->get() Definition at line 1000 of file Teuchos_ArrayRCP.hpp.
|
inline |
Create a new weak reference from another (strong) reference.
A "weak" reference gives access to the array, without incrementing its (strong) reference count. This lets you have access to the array, without affecting when it gets deallocated.
returnVal.is_valid_ptr()==truereturnVal.get() == this->get() returnVal.strong_count() == this->strong_count() returnVal.weak_count() == this->weak_count()+1 returnVal.strength() == RCP_WEAK returnVal.has_ownership() == this->has_ownership() Definition at line 1017 of file Teuchos_ArrayRCP.hpp.
|
inline |
Create a new strong RCP object from another (weak) RCP object.
A "weak" reference gives access to the array, without incrementing its (strong) reference count. This method lets you "promote" a weak reference into a strong reference. If the array has been deallocated, the returned reference is null.
returnVal.is_valid_ptr()==truereturnVal.get() == this->get() returnVal.strong_count() == this->strong_count()+1 returnVal.weak_count() == this->weak_count() returnVal.strength() == RCP_STRONG returnVal.has_ownership() == this->has_ownership() Definition at line 1030 of file Teuchos_ArrayRCP.hpp.
|
inline |
Returns true if the smart pointers share the same underlying reference-counted object.
This method does more than just check if this->get() == r_ptr.get(). It also checks to see if the underlying reference counting machinery is the same.
Definition at line 1045 of file Teuchos_ArrayRCP.hpp.
|
inline |
Throws NullReferenceError if this->get()==NULL, otherwise returns reference to *this.
Definition at line 1070 of file Teuchos_ArrayRCP.hpp.
|
inline |
Throws NullReferenceError if this->get()==NULL orthis->get()!=NULL, throws RangeError if (lowerOffset < this->lowerOffset() || this->upperOffset() < upperOffset, otherwise returns reference to *this
Definition at line 1109 of file Teuchos_ArrayRCP.hpp.
|
inline |
If the object pointer is non-null, assert that it is still valid.
If is_null()==false && strong_count()==0, this will throw DanglingReferenceErorr with a great error message.
If is_null()==true, then this will not throw any exception.
In this context, null is a valid object.
Definition at line 1089 of file Teuchos_ArrayRCP.hpp.
Wrap an RCP<Array<T> > object as an ArrayRCP<T> object.
Definition at line 512 of file Teuchos_Array.hpp.
Wrap a RCP<const Array<T> > object as an ArrayRCP<const T> object.
Definition at line 529 of file Teuchos_Array.hpp.
Wrap an Array<T> object as a non-owning ArrayRCP<T> object.
Definition at line 546 of file Teuchos_Array.hpp.
Wrap a const Array<T> object as a non-owning ArrayRCP<T> object.
Definition at line 564 of file Teuchos_Array.hpp.
|
related |
Wraps a preallocated array of data with the assumption to call the array version of delete.
|
related |
Wraps a preallocated array of data and uses a templated deallocation strategy object to define deletion .
Allocate a new array just given a dimension.
Warning! The memory is allocated using new T[size] and is not initialized (unless there is a default constructor for a user-defined type).
When called with 'size == 0' it returns a null ArrayRCP object.
Allocate a new ArrayRCP object with a new RCPNode with memory pointing to the initial node.
The purpose of this function is to create a new "handle" to the array of memory with its own seprate reference count. The new ArrayRCP object will have a new RCPNodeTmpl object that has a copy of the input ArrayRCP object embedded in it. This maintains the correct reference counting behaviors but now gives a private count. One would want to use arcpCloneNode(...) whenever it is important to keep a private reference count which is needed for some types of use cases.
Allocate a new array by cloning data from an input array view.
|
related |
Create an ArrayRCP with and also put in an embedded object.
In this case the embedded object is destroyed (by setting to Embedded()) before the object at *p is destroyed.
The embedded object can be extracted using getEmbeddedObj() and getNonconstEmbeddedObject().
|
related |
Create an ArrayRCP with and also put in an embedded object.
In this case the embedded object is destroyed (by setting to Embedded()) after the object at *p is destroyed.
The embedded object can be extracted using getEmbeddedObj() and getNonconstEmbeddedObject().
|
related |
Create an ArrayRCP with and also put in an embedded object.
This function should be called when it is not important when the embedded object is destroyed (by setting to Embedded()) with respect to when *p is destroyed.
The embedded object can be extracted using getEmbeddedObj() and getNonconstEmbeddedObject().
Wrap an std::vector<T> object as an ArrayRCP<T> object.
Wrap a const std::vector<T> object as an ArrayRCP<const T> object.
Get an std::vector<T> object out of an ArrayRCP<T> object that was created using the arcp() function above to wrap the std::vector in the first place..
|
related |
Get a const std::vector<T> object out of an ArrayRCP<const T> object that was created using the arcp() above to wrap the std::vector in the first place.
|
related |
Returns true if p.get()==NULL.
|
related |
Returns true if p.get()!=NULL.
Returns true if p.get()==NULL.
Returns true if p.get()!=NULL.
|
related |
Compare two ArrayRCP objects for equality (by pointers).
|
related |
Compare two ArrayRCP objects for inequality (by pointers).
|
related |
Compare the two ArrayRCP objects' pointers using <.
|
related |
Compare the two ArrayRCP objects' pointers using <=.
|
related |
Compare the two ArrayRCP objects' pointers using >.
|
related |
Compare the two ArrayRCP objects' pointers using >=.
|
related |
Const cast of underlying ArrayRCP type from const T* to T*.
The function will compile only if the following code compiles:
|
related |
Reinterpret cast of underlying ArrayRCP type from T1* to T2*.
The function will compile only if the following code compiles:
|
related |
Reinterpret cast of underlying ArrayRCP type from T1* to T2* where T2 is a non-POD (non-plain-old-data).
The function will compile only if (reinterpret_cast<T2*>(p1.get());) compiles.
This function is used to reinterpret-cast an array of plain-old-data (POD) (e.g. int or char) into an array of objects of type T2, which is not a plain-old-data type. The constructors will be called on each of the memory locations with placement new and the destructors will get called when the last ArrayRCP goes away.
|
related |
Implicit case the underlying ArrayRCP type from T1* to T2*.
The function will compile only if (T2 *p = p1.get();) compiles.
Warning! Do not use this function unless you absolutely know what you are doing. While implicit casting of pointers to single objects is usually 100% safe, implicit casting pointers to arrays of objects can be very dangerous. One std::exception that is always safe is when you are implicit casting an array of pointers to non-const objects to an array of const pointers to const objects. For example, the following implicit conversion from a array pointer objects aptr1 of type ArrayRCP<T*> to
is always legal and safe to do.
|
related |
Set extra data associated with a ArrayRCP object.
| extra_data | [in] Data object that will be set (copied) |
| name | [in] The name given to the extra data. The value of name together with the data type T1 of the extra data must be unique from any other such data or the other data will be overwritten. |
| p | [out] On output, will be updated with the input extra_data |
| destroy_when | [in] Determines when extra_data will be destroyed in relation to the underlying reference-counted object. If destroy_when==PRE_DESTROY then extra_data will be deleted before the underlying reference-counted object. If destroy_when==POST_DESTROY (the default) then extra_data will be deleted after the underlying reference-counted object. |
| force_unique | [in] Determines if this type and name pair must be unique in which case if an object with this same type and name already exists, then an std::exception will be thrown. The default is true for safety. |
If there is a call to this function with the same type of extra data T1 and same arguments p and name has already been made, then the current piece of extra data already set will be overwritten with extra_data. However, if the type of the extra data T1 is different, then the extra data can be added and not overwrite existing extra data. This means that extra data is keyed on both the type and name. This helps to minimize the chance that clients will unexpectedly overwrite data by accident.
When the last RefcountPtr object is removed and the reference-count node is deleted, then objects are deleted in the following order: (1) All of the extra data that where added with destroy_when==PRE_DESTROY are first, (2) then the underlying reference-counted object is deleted, and (3) the rest of the extra data that was added with destroy_when==PRE_DESTROY is then deleted. The order in which the objects are destroyed is not guaranteed. Therefore, clients should be careful not to add extra data that has deletion dependencies (instead consider using nested ArrayRCP objects as extra data which will guarantee the order of deletion).
Preconditions:
p->get() != NULL (throws NullReferenceError) T1 for extra_data and the same std::string name and force_unique==true, then an std::invalid_argument std::exception will be thrown. Note, this function is made a non-member function to be consistent with the non-member get_extra_data() functions.
|
related |
Get a non-const reference to extra data associated with a ArrayRCP object.
| p | [in] Smart pointer object that extra data is being extracted from. |
| name | [in] Name of the extra data. |
Preconditions:
p.get() != NULL (throws NullReferenceError) name and T1 must have been used in a previous call to set_extra_data() (throws std::invalid_argument). Note, this function must be a non-member function since the client must manually select the first template argument.
|
related |
Get a const reference to extra data associated with a ArrayRCP object.
| p | [in] Smart pointer object that extra data is being extracted from. |
| name | [in] Name of the extra data. |
Preconditions:
p.get() != NULL (throws NullReferenceError) name and T1 must have been used in a previous call to set_extra_data() (throws std::invalid_argument). Note, this function must be a non-member function since the client must manually select the first template argument.
Also note that this const version is a false sense of security since a client can always copy a const ArrayRCP object into a non-const object and then use the non-const version to change the data. However, its presence will help to avoid some types of accidental changes to this extra data.
|
related |
Get a pointer to non-const extra data (if it exists) associated with a ArrayRCP object.
| p | [in] Smart pointer object that extra data is being extracted from. |
| name | [in] Name of the extra data. |
Preconditions:
p.get() != NULL (throws NullReferenceError) Postconditions:
name and T1 have been used in a previous call to set_extra_data() then return !=NULL and otherwise return == NULL. Note, this function must be a non-member function since the client must manually select the first template argument.
|
related |
Get a pointer to const extra data (if it exists) associated with a ArrayRCP object.
| p | [in] Smart pointer object that extra data is being extracted from. |
| name | [in] Name of the extra data. |
Preconditions:
p.get() != NULL (throws NullReferenceError) Postconditions:
name and T1 have been used in a previous call to set_extra_data() then return !=NULL and otherwise return == NULL. Note, this function must be a non-member function since the client must manually select the first template argument.
Also note that this const version is a false sense of security since a client can always copy a const ArrayRCP object into a non-const object and then use the non-const version to change the data. However, its presence will help to avoid some types of accidental changes to this extra data.
|
related |
Return a non-const reference to the underlying deallocator object.
Preconditions:
p.get() != NULL (throws NullReferenceError) p is same as Dealloc_T (throws NullReferenceError)
|
related |
Return a const reference to the underlying deallocator object.
Preconditions:
p.get() != NULL (throws NullReferenceError) p is same as Dealloc_T (throws NullReferenceError) Note that the const version of this function provides only a very ineffective attempt to avoid accidental changes to the deallocation object. A client can always just create a new non-const ArrayRCP<T> object from any const ArrayRCP<T> object and then call the non-const version of this function.
|
related |
Return a pointer to the underlying non-const deallocator object if it exists.
Preconditions:
p.get() != NULL (throws NullReferenceError) Postconditions:
p is same as Dealloc_T then return!=NULL, otherwise return==NULL
|
related |
Return a pointer to the underlying const deallocator object if it exists.
Preconditions:
p.get() != NULL (throws NullReferenceError) Postconditions:
p is same as Dealloc_T then return!=NULL, otherwise return==NULL Note that the const version of this function provides only a very ineffective attempt to avoid accidental changes to the deallocation object. A client can always just create a new non-const ArrayRCP<T> object from any const ArrayRCP<T> object and then call the non-const version of this function.
|
related |
Get a const reference to an embedded object that was set by calling arcpWithEmbeddedObjPreDestroy(), arcpWithEmbeddedObjPostDestory(), or arcpWithEmbeddedObj().
|
related |
Get a const reference to an embedded object that was set by calling arcpWithEmbeddedObjPreDestroy(), arcpWithEmbeddedObjPostDestory(), or arcpWithEmbeddedObj().
|
related |
Output stream inserter.
The implementation of this function just print pointer addresses and therefore puts not restrictions on the data types involved.
1.8.5