Teuchos - Trilinos Tools Package  Version of the Day
Teuchos_ArrayRCPDecl.hpp
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Teuchos: Common Tools Package
5 // Copyright (2004) Sandia Corporation
6 //
7 // Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38 //
39 // ***********************************************************************
40 // @HEADER
41 
42 
43 #ifndef TEUCHOS_ARRAY_RCP_DECL_HPP
44 #define TEUCHOS_ARRAY_RCP_DECL_HPP
45 
46 
47 #include "Teuchos_RCP.hpp"
48 #include "Teuchos_Exceptions.hpp"
49 #include "Teuchos_ArrayViewDecl.hpp"
50 
51 
52 namespace Teuchos {
53 
126 template<class T>
127 class ArrayRCP {
128 public:
130 
131 
133  typedef Teuchos_Ordinal Ordinal;
134 
137 
140 
142  typedef std::random_access_iterator_tag iterator_category;
143 
145  typedef T* iterator_type;
146 
148  typedef T value_type;
149 
151  typedef T& reference;
152 
154  typedef const T& const_reference;
155 
157  typedef T* pointer;
158 
160  typedef T* const_pointer;
161 
163  typedef T element_type;
164 
165 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
166  typedef ArrayRCP<T> iterator;
170 #else
171  typedef T* iterator;
174  typedef const T* const_iterator;
175 #endif
176 
178 
180 
193  inline ArrayRCP( ENull null_arg = null );
194 
217  bool has_ownership, const ERCPNodeLookup rcpNodeLookup = RCP_ENABLE_NODE_LOOKUP );
218 
241  template<class Dealloc_T>
242  inline ArrayRCP( T* p, size_type lowerOffset, size_type size, Dealloc_T dealloc,
243  bool has_ownership );
244 
260  inline explicit ArrayRCP( size_type size, const T& val = T() );
261 
280  inline ArrayRCP(const ArrayRCP<T>& r_ptr);
281 
292  inline ~ArrayRCP();
293 
321  inline ArrayRCP<T>& operator=(const ArrayRCP<T>& r_ptr);
322 
324 
326 
328  inline bool is_null() const;
329 
337  inline T* operator->() const;
338 
346  inline T& operator*() const;
347 
353  inline T* get() const;
354 
360  inline T* getRawPtr() const;
361 
367  inline T& operator[](size_type offset) const;
368 
370 
372 
381  inline ArrayRCP<T>& operator++();
382 
391  inline ArrayRCP<T> operator++(int);
392 
401  inline ArrayRCP<T>& operator--();
402 
411  inline ArrayRCP<T> operator--(int);
412 
421  inline ArrayRCP<T>& operator+=(size_type offset);
422 
431  inline ArrayRCP<T>& operator-=(size_type offset);
432 
445  inline ArrayRCP<T> operator+(size_type offset) const;
446 
459  inline ArrayRCP<T> operator-(size_type offset) const;
460 
462 
464 
475  inline iterator begin() const;
476 
487  inline iterator end() const;
488 
490 
492 
498  inline ArrayRCP<const T> getConst() const;
499 
514 
516 
518 
520  inline size_type lowerOffset() const;
521 
523  inline size_type upperOffset() const;
524 
529  inline size_type size() const;
530 
532 
534 
549 
555 
560  inline ArrayView<T> operator()() const;
561 
563 
565 
572  inline operator ArrayRCP<const T>() const;
573 
575 
577 
582  inline void assign(size_type n, const T &val);
583 
591  template<class Iter>
592  inline void assign(Iter first, Iter last);
593 
599  inline void deepCopy(const ArrayView<const T>& av);
600 
602  inline void resize(const size_type n, const T &val = T());
603 
608  inline void clear();
609 
611 
613 
625  inline ERCPStrength strength() const;
626 
636  inline bool is_valid_ptr() const;
637 
643  inline int strong_count() const;
644 
650  inline int weak_count() const;
651 
653  inline int total_count() const;
654 
672  inline void set_has_ownership();
673 
685  inline bool has_ownership() const;
686 
707  inline T* release();
708 
723  inline ArrayRCP<T> create_weak() const;
724 
740  inline ArrayRCP<T> create_strong() const;
741 
748  template<class T2>
749  inline bool shares_resource(const ArrayRCP<T2>& r_ptr) const;
750 
752 
754 
758  inline const ArrayRCP<T>& assert_not_null() const;
759 
766 
776  inline const ArrayRCP<T>& assert_valid_ptr() const;
777 
779 
781 
783  inline TEUCHOS_DEPRECATED int count() const;
784 
786 
787 private:
789  T *ptr_;
791  RCPNodeHandle node_;
793  size_type lowerOffset_;
795  size_type upperOffset_;
796 
797  inline void debug_assert_not_null () const {
798 #ifdef TEUCHOS_REFCOUNTPTR_ASSERT_NONNULL
799  assert_not_null();
800 #endif
801  }
802 
803  inline void
804  debug_assert_in_range (size_type lowerOffset_in,
805  size_type size_in) const
806  {
807  (void) lowerOffset_in;
808  (void) size_in;
809 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
810  assert_in_range (lowerOffset_in, size_in);
811 #endif
812  }
813 
814  inline void debug_assert_valid_ptr() const {
815 #ifdef TEUCHOS_DEBUG
816  assert_valid_ptr ();
817 #endif
818  }
819 
820 public:
821 
822 #ifndef DOXYGEN_COMPILE
823  // These constructors should be private but I have not had good luck making
824  // this portable (i.e. using friendship etc.) in the past
825  // This is a very bad breach of encapsulation that is needed since MS VC++
826  // 5.0 will not allow me to declare template functions as friends.
828  const RCPNodeHandle& node );
829  T* access_private_ptr() const;
830  RCPNodeHandle& nonconst_access_private_node();
831  const RCPNodeHandle& access_private_node() const;
832 #endif
833 
834 };
835 
836 
844 template<class T>
845 class ArrayRCP<const T> {
846 public:
847  typedef Teuchos_Ordinal Ordinal;
848  typedef Ordinal size_type;
849  typedef Ordinal difference_type;
850  typedef std::random_access_iterator_tag iterator_category;
851  typedef const T* iterator_type;
852  typedef const T value_type;
853  typedef const T& reference;
854  typedef const T& const_reference;
855  typedef const T* pointer;
856  typedef const T* const_pointer;
857  typedef const T element_type;
858 
859 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
860  typedef ArrayRCP<const T> iterator;
862 #else
863  typedef const T* iterator;
864  typedef const T* const_iterator;
865 #endif
866 
867  inline ArrayRCP (ENull null_arg = null);
868  inline ArrayRCP (const T* p, size_type lowerOffset,
869  size_type size, bool has_ownership,
870  const ERCPNodeLookup rcpNodeLookup = RCP_ENABLE_NODE_LOOKUP);
871  template<class Dealloc_T>
872  inline ArrayRCP (const T* p, size_type lowerOffset, size_type size,
873  Dealloc_T dealloc, bool has_ownership);
874  inline explicit ArrayRCP (size_type size, const T& val = T ());
875  inline ArrayRCP (const ArrayRCP<const T>& r_ptr);
876  inline ~ArrayRCP();
877 
878  inline ArrayRCP<const T>& operator= (const ArrayRCP<const T>& r_ptr);
879  inline bool is_null() const;
880  inline const T* operator->() const;
881  inline const T& operator*() const;
882  inline const T* get() const;
883  inline const T* getRawPtr() const;
884  inline const T& operator[] (size_type offset) const;
885 
886  inline ArrayRCP<const T>& operator++ ();
887  inline ArrayRCP<const T> operator++ (int);
888  inline ArrayRCP<const T>& operator-- ();
889  inline ArrayRCP<const T> operator-- (int);
890  inline ArrayRCP<const T>& operator+= (size_type offset);
891  inline ArrayRCP<const T>& operator-= (size_type offset);
892  inline ArrayRCP<const T> operator+ (size_type offset) const;
893  inline ArrayRCP<const T> operator- (size_type offset) const;
894 
895  inline iterator begin() const;
896  inline iterator end() const;
897 
903  inline ArrayRCP<const T> getConst () const;
904  inline ArrayRCP<const T> persistingView (size_type lowerOffset, size_type size) const;
905 
906  inline size_type lowerOffset() const;
907  inline size_type upperOffset() const;
908  inline size_type size() const;
909 
910  inline ArrayView<const T> view (size_type lowerOffset, size_type size) const;
911  inline ArrayView<const T> operator() (size_type lowerOffset, size_type size) const;
912  inline ArrayView<const T> operator() () const;
913 
914  inline void resize (const size_type n, const T& val = T ());
915  inline void clear ();
916 
917  inline ERCPStrength strength() const;
918  inline bool is_valid_ptr() const;
919  inline int strong_count() const;
920  inline int weak_count() const;
921  inline int total_count() const;
922  inline void set_has_ownership();
923  inline bool has_ownership() const;
924  inline const T* release();
925  inline ArrayRCP<const T> create_weak() const;
926  inline ArrayRCP<const T> create_strong() const;
927 
928  template<class T2>
929  inline bool shares_resource (const ArrayRCP<T2>& r_ptr) const;
930 
931  inline const ArrayRCP<const T>& assert_not_null () const;
932  inline const ArrayRCP<const T>& assert_in_range (size_type lowerOffset, size_type size) const;
933  inline const ArrayRCP<const T>& assert_valid_ptr() const;
934 
935  inline TEUCHOS_DEPRECATED int count() const;
936 
937 private:
938  const T* ptr_; // NULL if this pointer is null
939  RCPNodeHandle node_; // NULL if this pointer is null
940  size_type lowerOffset_; // 0 if this pointer is null
941  size_type upperOffset_; // -1 if this pointer is null
942 
943  inline void debug_assert_not_null() const {
944 #ifdef TEUCHOS_REFCOUNTPTR_ASSERT_NONNULL
945  assert_not_null ();
946 #endif
947  }
948 
949  inline void
950  debug_assert_in_range (size_type lowerOffset_in,
951  size_type size_in) const
952  {
953  (void) lowerOffset_in; (void) size_in;
954 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
955  assert_in_range (lowerOffset_in, size_in);
956 #endif
957  }
958 
959  inline void debug_assert_valid_ptr() const {
960 #ifdef TEUCHOS_DEBUG
961  assert_valid_ptr ();
962 #endif
963  }
964 
965 public:
966 
967 #ifndef DOXYGEN_COMPILE
968  // These constructors should be private but I have not had good luck making
969  // this portable (i.e. using friendship etc.) in the past
970  // This is a very bad breach of encapsulation that is needed since MS VC++
971  // 5.0 will not allow me to declare template functions as friends.
972  ArrayRCP (const T* p, size_type lowerOffset,
973  size_type size, const RCPNodeHandle& node);
974  const T* access_private_ptr() const;
975  RCPNodeHandle& nonconst_access_private_node();
976  const RCPNodeHandle& access_private_node() const;
977 #endif
978 };
979 
980 
989 template<>
990 class ArrayRCP<void> {
991 public:
992  typedef Teuchos_Ordinal Ordinal;
993  typedef Ordinal size_type;
994  typedef Ordinal difference_type;
995  typedef std::random_access_iterator_tag iterator_category;
996  typedef void* iterator_type;
997  typedef void value_type;
999  // typedef T& reference; // these are not valid
1001  // typedef const T& const_reference; // these are not valid
1002  typedef void* pointer;
1003  typedef void* const_pointer;
1004  typedef void element_type;
1005 
1007  inline ArrayRCP ();
1008 };
1009 
1014 template<>
1015 class ArrayRCP<const void> {
1016 public:
1017  typedef Teuchos_Ordinal Ordinal;
1018  typedef Ordinal size_type;
1019  typedef Ordinal difference_type;
1020  typedef std::random_access_iterator_tag iterator_category;
1021  typedef const void* iterator_type;
1022  typedef const void value_type;
1024  // typedef T& reference; // these are not valid
1026  // typedef const T& const_reference; // these are not valid
1027  typedef const void* pointer;
1028  typedef const void* const_pointer;
1029  typedef const void element_type;
1030 
1032  inline ArrayRCP ();
1033 };
1034 
1035 // 2008/09/22: rabartl: NOTE: I removed the TypeNameTraits<ArrayRCP<T> >
1036 // specialization since I want to be able to print the type name of an
1037 // ArrayRCP that does not have the type T fully defined!
1038 
1039 
1044 template<typename T>
1046 public:
1047  static ArrayRCP<T> getNull() { return null; }
1048 };
1049 
1050 
1056 template<class T>
1057 ArrayRCP<T> arcp(
1058  T* p,
1059  typename ArrayRCP<T>::size_type lowerOffset,
1060  typename ArrayRCP<T>::size_type size,
1061  bool owns_mem = true
1062  );
1063 
1064 
1070 template<class T, class Dealloc_T>
1071 ArrayRCP<T> arcp(
1072  T* p,
1073  typename ArrayRCP<T>::size_type lowerOffset,
1074  typename ArrayRCP<T>::size_type size,
1075  Dealloc_T dealloc, bool owns_mem
1076  );
1077 
1078 
1089 template<class T>
1090 ArrayRCP<T> arcp( typename ArrayRCP<T>::size_type size );
1091 
1092 
1106 template<class T>
1107 ArrayRCP<T> arcpCloneNode( const ArrayRCP<T> &a );
1108 
1109 
1114 template<class T>
1115 ArrayRCP<T> arcpClone( const ArrayView<const T> &v );
1116 
1117 
1128 template<class T, class Embedded>
1130 arcpWithEmbeddedObjPreDestroy(
1131  T* p,
1132  typename ArrayRCP<T>::size_type lowerOffset,
1133  typename ArrayRCP<T>::size_type size,
1134  const Embedded &embedded,
1135  bool owns_mem = true
1136  );
1137 
1138 
1149 template<class T, class Embedded>
1151 arcpWithEmbeddedObjPostDestroy(
1152  T* p,
1153  typename ArrayRCP<T>::size_type lowerOffset,
1154  typename ArrayRCP<T>::size_type size,
1155  const Embedded &embedded,
1156  bool owns_mem = true
1157  );
1158 
1159 
1171 template<class T, class Embedded>
1173 arcpWithEmbeddedObj(
1174  T* p,
1175  typename ArrayRCP<T>::size_type lowerOffset,
1176  typename ArrayRCP<T>::size_type size,
1177  const Embedded &embedded,
1178  bool owns_mem = true
1179  );
1180 
1181 
1187 template<class T>
1188 ArrayRCP<T> arcp( const RCP<std::vector<T> > &v );
1189 
1190 
1196 template<class T>
1197 ArrayRCP<const T> arcp( const RCP<const std::vector<T> > &v );
1198 
1199 
1208 template<class T>
1209 ArrayRCP<T> arcpFromArrayView(const ArrayView<T> &av);
1210 
1211 
1219 template<class T>
1220 RCP<std::vector<T> > get_std_vector( const ArrayRCP<T> &ptr );
1221 
1222 
1229 template<class T>
1230 RCP<const std::vector<T> > get_std_vector( const ArrayRCP<const T> &ptr );
1231 
1232 
1237 template<class T>
1238 bool is_null( const ArrayRCP<T> &p );
1239 
1240 
1245 template<class T>
1246 bool nonnull( const ArrayRCP<T> &p );
1247 
1248 
1253 template<class T>
1254 bool operator==( const ArrayRCP<T> &p, ENull );
1255 
1256 
1261 template<class T>
1262 bool operator!=( const ArrayRCP<T> &p, ENull );
1263 
1264 
1269 template<class T1, class T2>
1270 bool operator==( const ArrayRCP<T1> &p1, const ArrayRCP<T2> &p2 );
1271 
1272 
1277 template<class T1, class T2>
1278 bool operator!=( const ArrayRCP<T1> &p1, const ArrayRCP<T2> &p2 );
1279 
1280 
1285 template<class T1, class T2>
1286 bool operator<( const ArrayRCP<T1> &p1, const ArrayRCP<T2> &p2 );
1287 
1288 
1293 template<class T1, class T2>
1294 bool operator<=( const ArrayRCP<T1> &p1, const ArrayRCP<T2> &p2 );
1295 
1296 
1301 template<class T1, class T2>
1302 bool operator>( const ArrayRCP<T1> &p1, const ArrayRCP<T2> &p2 );
1303 
1304 
1309 template<class T1, class T2>
1310 bool operator>=( const ArrayRCP<T1> &p1, const ArrayRCP<T2> &p2 );
1311 
1312 
1320 template<class T>
1322 operator-( const ArrayRCP<T> &p1, const ArrayRCP<T> &p2 );
1323 
1324 
1335 template<class T2, class T1>
1336 inline
1337 ArrayRCP<T2> arcp_const_cast(const ArrayRCP<T1>& p1);
1338 
1339 
1351 template<class T2, class T1>
1352 ArrayRCP<T2> arcp_reinterpret_cast(const ArrayRCP<T1>& p1);
1353 
1354 
1371 template<class T2, class T1>
1372 ArrayRCP<T2> arcp_reinterpret_cast_nonpod(const ArrayRCP<T1>& p1, const T2& val=T2());
1373 
1374 
1400 template<class T2, class T1>
1401 inline
1402 ArrayRCP<T2> arcp_implicit_cast(const ArrayRCP<T1>& p1);
1403 
1404 
1463 template<class T1, class T2>
1464 void set_extra_data(
1465  const T1 &extra_data, const std::string& name,
1466  const Ptr<ArrayRCP<T2> > &p, EPrePostDestruction destroy_when = POST_DESTROY,
1467  bool force_unique = true );
1468 
1469 
1489 template<class T1, class T2>
1490 T1& get_extra_data( ArrayRCP<T2>& p, const std::string& name );
1491 
1492 
1518 template<class T1, class T2>
1519 const T1& get_extra_data( const ArrayRCP<T2>& p, const std::string& name );
1520 
1521 
1546 template<class T1, class T2>
1547 T1* get_optional_extra_data( ArrayRCP<T2>& p, const std::string& name );
1548 
1549 
1579 template<class T1, class T2>
1580 const T1* get_optional_extra_data( const ArrayRCP<T2>& p, const std::string& name );
1581 
1582 
1593 template<class Dealloc_T, class T>
1594 Dealloc_T& get_nonconst_dealloc( const ArrayRCP<T>& p );
1595 
1596 
1614 template<class Dealloc_T, class T>
1615 const Dealloc_T& get_dealloc( const ArrayRCP<T>& p );
1616 
1617 
1632 template<class Dealloc_T, class T>
1633 const Dealloc_T* get_optional_dealloc( const ArrayRCP<T>& p );
1634 
1635 
1657 template<class Dealloc_T, class T>
1658 Dealloc_T* get_optional_nonconst_dealloc( const ArrayRCP<T>& p );
1659 
1660 
1667 template<class TOrig, class Embedded, class T>
1668 const Embedded& getEmbeddedObj( const ArrayRCP<T>& p );
1669 
1670 
1677 template<class TOrig, class Embedded, class T>
1678 Embedded& getNonconstEmbeddedObj( const ArrayRCP<T>& p );
1679 
1680 
1688 template<class T>
1689 std::ostream& operator<<( std::ostream& out, const ArrayRCP<T>& p );
1690 
1691 
1692 } // end namespace Teuchos
1693 
1694 
1695 #endif // TEUCHOS_ARRAY_RCP_DECL_HPP
const T * const_iterator
Constant iterator type used if bounds checking is disabled.
ArrayRCP< T > create_weak() const
Create a new weak reference from another (strong) reference.
std::random_access_iterator_tag iterator_category
Category of ArrayRCP&#39;s iterator type.
ArrayRCP< T > operator+(size_type offset) const
Pointer integer increment (i.e. ptr+offset).
ArrayRCP(ENull null_arg=null)
Default constructor; initialize to an empty array.
Partial specialization of ArrayRCP for const T.
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.
bool is_null(const std::shared_ptr< T > &p)
Returns true if p.get()==NULL.
ArrayRCP< T > & operator-=(size_type offset)
Pointer integer increment (i.e. ptr-=offset).
int strong_count() const
Return the number of active RCP<> objects that have a "strong" reference to the underlying reference-...
ArrayRCP< T > & operator--()
Prefix decrement of pointer (i.e. –ptr).
T * release()
Release the ownership of the underlying array.
const ArrayRCP< T > & assert_not_null() const
Throws NullReferenceError if this->get()==NULL, otherwise returns reference to *this.
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.
T element_type
Type of each array element.
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.
T * const_pointer
Type of a (raw) (constant) pointer to an array element.
Teuchos_Ordinal Ordinal
Integer index type used throughout ArrayRCP.
bool has_ownership() const
Returns true if this has ownership of object pointed to by this->get() in order to deallocate it...
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.
T value_type
Type of each array element.
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.
ERCPStrength
Used to specify if the pointer is weak or strong.
size_type upperOffset() const
Return the upper offset to valid data.
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.
Base traits class for getting a properly initialized null pointer.
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.
T * iterator_type
Type of an ArrayRCP&#39;s iterator.
const T & const_reference
Type of a (constant) reference to an array element.
bool is_null() const
True if the underlying pointer is null, else false.
T * pointer
Type of a (raw) (nonconstant) pointer to an array element.
Nonowning array view.
void set_has_ownership()
Give this and other ArrayRCP<> objects ownership of the underlying referenced array to delete it...
The Teuchos namespace contains all of the classes, structs and enums used by Teuchos, as well as a number of utility routines.
Handle class that manages the RCPNode&#39;s reference counting.
ArrayView< T > view(size_type lowerOffset, size_type size) const
Return a nonpersisting view of a contiguous range of elements.
ERCPNodeLookup
Used to determine if RCPNode lookup is performed or not.
EPrePostDestruction
Used to specify a pre or post destruction of extra data.
T & operator*() const
Dereference the underlying object for the current pointer position.
ArrayRCP< T > & operator=(const ArrayRCP< T > &r_ptr)
Assignment operator: Makes *this reference the input array.
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).
T * iterator
Nonconstant iterator type used if bounds checking is disabled.
Partial specialization of ArrayView for const T.
T & reference
Type of a (nonconstant) reference to an array element.
size_type lowerOffset() const
Return the lower offset to valid data.
Reference-counted pointer class and non-member templated function implementations.
Simple wrapper class for raw pointers to single objects where no persisting relationship exists...
void assign(size_type n, const T &val)
Resize and assign n elements of val.
Reference-counted smart pointer for managing arrays.
ArrayView< T > operator()() const
Return a nonpersisting view of *this.
T * operator->() const
Pointer (->) access to members of underlying object for current position.