template<class T> inline
T* ArrayRCP<T>::release()
{
debug_assert_valid_ptr();
node_.has_ownership(false);
return ptr_;
}
template<class T> inline
T* Ptr<T>::operator->() const
{
debug_assert_not_null();
debug_assert_valid_ptr();
return ptr_;
}
template<class T> inline
typename ArrayRCP<T>::size_type
ArrayRCP<T>::size() const
{
debug_assert_valid_ptr();
return upperOffset_ - lowerOffset_ + 1;
}
template<class T> inline
T& ArrayRCP<T>::operator[](size_type offset) const
{
debug_assert_valid_ptr();
debug_assert_in_range(offset,1);
return ptr_[offset];
}
template<class T> inline
T& ArrayRCP<T>::operator*() const
{
debug_assert_valid_ptr();
debug_assert_in_range(0,1);
return *ptr_;
}
template<class T> inline
ArrayRCP<T> ArrayRCP<T>::operator--(int)
{
debug_assert_valid_ptr();
ArrayRCP<T> r_ptr = *this;
--(*this);
return r_ptr;
}
template<class T> inline
ArrayRCP<T>& ArrayRCP<T>::operator-=(size_type offset)
{
debug_assert_valid_ptr();
ptr_ -= offset;
lowerOffset_ += offset;
upperOffset_ += offset;
return *this;
}
template<class T> inline
ArrayRCP<T>& ArrayRCP<T>::operator--()
{
debug_assert_valid_ptr();
--ptr_;
++lowerOffset_;
++upperOffset_;
return *this;
}
template<class T> inline
T* ArrayRCP<T>::get() const
{
if(ptr_) {
debug_assert_valid_ptr();
debug_assert_in_range(0,1);
}
return ptr_;
}
template<class T> inline
ArrayRCP<const T> ArrayRCP<T>::getConst() const
{
if (ptr_) {
debug_assert_valid_ptr();
const T *cptr = ptr_; // Will not compile if not legal!
return ArrayRCP<const T>(cptr, lowerOffset_, size(), node_);
}
return null;
}
template<class T> inline
typename ArrayRCP<T>::iterator ArrayRCP<T>::end() const
{
debug_assert_valid_ptr();
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
return *this + (upperOffset_ + 1);
#else
return ptr_ + (upperOffset_ + 1);
#endif
}
template<class T> inline
ArrayView<T> ArrayRCP<T>::view( size_type lowerOffset_in, size_type size_in ) const
{
debug_assert_valid_ptr();
debug_assert_in_range(lowerOffset_in,size_in);
#ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
return ArrayView<T>(persistingView(lowerOffset_in, size_in).create_weak());
#else
return arrayView(ptr_ + lowerOffset_in, size_in);
#endif
// ToDo: Implement checks for dangling references!
}
template<class T> inline
ArrayRCP<T>
ArrayRCP<T>::persistingView( size_type lowerOffset_in, size_type size_in ) const
{
debug_assert_valid_ptr();
debug_assert_in_range(lowerOffset_in, size_in);
ArrayRCP<T> ptr = *this;
ptr.ptr_ = ptr.ptr_ + lowerOffset_in;
ptr.lowerOffset_ = 0;
ptr.upperOffset_ = size_in - 1;
return ptr;
}
template<class T> inline
T* Ptr<T>::get() const
{
debug_assert_valid_ptr();
return ptr_;
}
template<class T> inline
ArrayRCP<T> ArrayRCP<T>::create_strong() const
{
debug_assert_valid_ptr();
return ArrayRCP<T>(ptr_, lowerOffset_, size(), node_.create_strong());
}
