dune-istl  2.2.0
Public Types | Public Member Functions | Protected Attributes
Dune::base_array_window< B, A > Class Template Reference

Extend base_array_unmanaged by functions to manipulate. More...

#include <dune/istl/basearray.hh>

Inheritance diagram for Dune::base_array_window< B, A >:
Dune::base_array_unmanaged< B, A >

List of all members.

Public Types

typedef B member_type
 export the type representing the components
typedef A allocator_type
 export the allocator type
typedef base_array_unmanaged
< B, A >::iterator 
iterator
 make iterators available as types
typedef base_array_unmanaged
< B, A >::const_iterator 
const_iterator
 make iterators available as types
typedef base_array_unmanaged
< B, A >::size_type 
size_type
 The type used for the index access.
typedef A::difference_type difference_type
 The type used for the difference between two iterator positions.

Public Member Functions

 base_array_window ()
 makes empty array
 base_array_window (B *_p, size_type _n)
 make array from given pointer and size
void set (size_type _n, B *_p)
 set pointer and length
void advance (difference_type newsize)
 advance pointer by newsize elements and then set size to new size
void move (difference_type offset, size_type newsize)
 increment pointer by offset and set size
void move (difference_type offset)
 increment pointer by offset, leave size
B * getptr ()
 return the pointer
B & operator[] (size_type i)
 random access to blocks
const B & operator[] (size_type i) const
 same for read only access
iterator begin ()
 begin iterator
const_iterator begin () const
 begin const_iterator
iterator end ()
 end iterator
const_iterator end () const
 end const_iterator
iterator beforeEnd ()
const_iterator beforeEnd () const
iterator beforeBegin ()
const_iterator beforeBegin () const
iterator find (size_type i)
 random access returning iterator (end if not contained)
const_iterator find (size_type i) const
 random access returning iterator (end if not contained)
size_type size () const
 number of blocks in the array (are of size 1 here)

Protected Attributes

size_type n
B * p

Detailed Description

template<class B, class A = std::allocator<B>>
class Dune::base_array_window< B, A >

Extend base_array_unmanaged by functions to manipulate.

This container has *NO* memory management at all, copy constuctor, assignment and destructor are all default. A container can be constructed as empty or from a given pointer and size. This class is used to implement a view into a larger array.

You can copy such an object to a base_array to make a real copy.

Error checking: no error checking is provided normally. Setting the compile time switch DUNE_ISTL_WITH_CHECKING enables error checking.


Member Typedef Documentation

template<class B, class A = std::allocator<B>>
typedef A Dune::base_array_window< B, A >::allocator_type

export the allocator type

Reimplemented from Dune::base_array_unmanaged< B, A >.

template<class B, class A = std::allocator<B>>
typedef base_array_unmanaged<B,A>::const_iterator Dune::base_array_window< B, A >::const_iterator

make iterators available as types

Reimplemented from Dune::base_array_unmanaged< B, A >.

template<class B, class A = std::allocator<B>>
typedef A::difference_type Dune::base_array_window< B, A >::difference_type

The type used for the difference between two iterator positions.

template<class B, class A = std::allocator<B>>
typedef base_array_unmanaged<B,A>::iterator Dune::base_array_window< B, A >::iterator

make iterators available as types

Reimplemented from Dune::base_array_unmanaged< B, A >.

template<class B, class A = std::allocator<B>>
typedef B Dune::base_array_window< B, A >::member_type

export the type representing the components

Reimplemented from Dune::base_array_unmanaged< B, A >.

template<class B, class A = std::allocator<B>>
typedef base_array_unmanaged<B,A>::size_type Dune::base_array_window< B, A >::size_type

The type used for the index access.

Reimplemented from Dune::base_array_unmanaged< B, A >.


Constructor & Destructor Documentation

template<class B, class A = std::allocator<B>>
Dune::base_array_window< B, A >::base_array_window ( ) [inline]

makes empty array

template<class B, class A = std::allocator<B>>
Dune::base_array_window< B, A >::base_array_window ( B *  _p,
size_type  _n 
) [inline]

make array from given pointer and size


Member Function Documentation

template<class B, class A = std::allocator<B>>
void Dune::base_array_window< B, A >::advance ( difference_type  newsize) [inline]

advance pointer by newsize elements and then set size to new size

References Dune::base_array_unmanaged< B, A >::n, and Dune::base_array_unmanaged< B, A >::p.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::beforeBegin ( ) [inline, inherited]
Returns:
an iterator that is positioned before the first entry of the vector.
template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::beforeBegin ( ) const [inline, inherited]
Returns:
an iterator that is positioned before the first entry of the vector.

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::beforeEnd ( ) [inline, inherited]
Returns:
an iterator that is positioned before the end iterator of the vector, i.e. at the last entry.

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::beforeEnd ( ) const [inline, inherited]
Returns:
an iterator that is positioned before the end iterator of the vector. i.e. at the last element.

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::begin ( ) [inline, inherited]

begin iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

Referenced by test_basearray(), and test_IO().

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::begin ( ) const [inline, inherited]

begin const_iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::end ( ) [inline, inherited]

end iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

Referenced by test_basearray(), and test_IO().

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::end ( ) const [inline, inherited]

end const_iterator

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::find ( size_type  i) [inline, inherited]

random access returning iterator (end if not contained)

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::find ( size_type  i) const [inline, inherited]

random access returning iterator (end if not contained)

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
B* Dune::base_array_window< B, A >::getptr ( ) [inline]

return the pointer

References Dune::base_array_unmanaged< B, A >::p.

template<class B, class A = std::allocator<B>>
void Dune::base_array_window< B, A >::move ( difference_type  offset,
size_type  newsize 
) [inline]

increment pointer by offset and set size

References Dune::base_array_unmanaged< B, A >::n, and Dune::base_array_unmanaged< B, A >::p.

Referenced by test_basearray().

template<class B, class A = std::allocator<B>>
void Dune::base_array_window< B, A >::move ( difference_type  offset) [inline]

increment pointer by offset, leave size

References Dune::base_array_unmanaged< B, A >::p.

template<class B, class A = std::allocator<B>>
B& Dune::base_array_unmanaged< B, A >::operator[] ( size_type  i) [inline, inherited]

random access to blocks

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
const B& Dune::base_array_unmanaged< B, A >::operator[] ( size_type  i) const [inline, inherited]

same for read only access

Reimplemented in Dune::VariableBlockVector< B, A >, and Dune::VariableBlockVector< T, A >.

template<class B, class A = std::allocator<B>>
void Dune::base_array_window< B, A >::set ( size_type  _n,
B *  _p 
) [inline]
template<class B, class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::size ( ) const [inline, inherited]

number of blocks in the array (are of size 1 here)

Referenced by Dune::Matrix< T, A >::coldim(), and Dune::BlockVector< FieldVector< T, n >, A >::resize().


Member Data Documentation

template<class B, class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::n [protected, inherited]

Referenced by Dune::base_array_window< B, A >::advance(), Dune::block_vector_unmanaged< T, A >::axpy(), Dune::base_array< B, A >::base_array(), Dune::base_array_unmanaged< T, A >::beforeEnd(), Dune::BlockVector< FieldVector< T, n >, A >::BlockVector(), Dune::BlockVectorWindow< B, A >::BlockVectorWindow(), Dune::block_vector_unmanaged< T, A >::dim(), Dune::base_array_unmanaged< T, A >::end(), Dune::base_array_unmanaged< T, A >::find(), Dune::BlockVectorWindow< B, A >::getsize(), Dune::block_vector_unmanaged< T, A >::infinity_norm(), Dune::block_vector_unmanaged< T, A >::infinity_norm_real(), Dune::base_array_window< B, A >::move(), Dune::block_vector_unmanaged< T, A >::N(), Dune::block_vector_unmanaged< T, A >::one_norm(), Dune::block_vector_unmanaged< T, A >::one_norm_real(), Dune::block_vector_unmanaged< T, A >::operator*(), Dune::block_vector_unmanaged< T, A >::operator*=(), Dune::VariableBlockVector< B, A >::CreateIterator::operator++(), Dune::block_vector_unmanaged< T, A >::operator+=(), Dune::block_vector_unmanaged< T, A >::operator-=(), Dune::block_vector_unmanaged< T, A >::operator/=(), Dune::block_vector_unmanaged< T, A >::operator=(), Dune::VariableBlockVector< T, A >::operator=(), Dune::BlockVector< FieldVector< T, n >, A >::operator=(), Dune::base_array< B, A >::operator=(), Dune::BlockVectorWindow< B, A >::operator=(), Dune::base_array_unmanaged< T, A >::operator[](), Dune::VariableBlockVector< T, A >::resize(), Dune::BlockVector< FieldVector< T, n >, A >::resize(), Dune::base_array< B, A >::resize(), Dune::base_array_window< B, A >::set(), Dune::BlockVectorWindow< B, A >::set(), Dune::BlockVectorWindow< B, A >::setsize(), Dune::base_array_unmanaged< T, A >::size(), Dune::block_vector_unmanaged< T, A >::two_norm(), Dune::block_vector_unmanaged< T, A >::two_norm2(), Dune::VariableBlockVector< T, A >::VariableBlockVector(), Dune::base_array< B, A >::~base_array(), and Dune::VariableBlockVector< T, A >::~VariableBlockVector().

template<class B, class A = std::allocator<B>>
B* Dune::base_array_unmanaged< B, A >::p [protected, inherited]

The documentation for this class was generated from the following file: