dune-istl 3.0-git
Public Types | Public Member Functions | Protected Attributes | List of all members
Dune::base_array< B, A > Class Template Reference

This container extends base_array_unmanaged by memory management with the usual copy semantics providing the full range of copy constructor, destructor and assignment operators. More...

#include <dune/istl/basearray.hh>

Inheritance diagram for Dune::base_array< B, A >:
Inheritance graph

Public Types

typedefmember_type
 export the type representing the components
 
typedefallocator_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 ()
 makes empty array
 
 base_array (size_type _n)
 make array with _n components
 
 base_array (const base_array &a)
 copy constructor
 
 base_array (const base_array_unmanaged< B, A > &_a)
 construct from base class object
 
 ~base_array ()
 free dynamic memory
 
void resize (size_type _n)
 reallocate array to given size, any data is lost
 
base_arrayoperator= (const base_array &a)
 assignment
 
base_arrayoperator= (const base_array_unmanaged< B, A > &a)
 assign from base class object
 
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

allocator_
 
size_type n
 
B * p
 

Detailed Description

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

This container extends base_array_unmanaged by memory management with the usual copy semantics providing the full range of copy constructor, destructor and assignment operators.

You can make

Member Typedef Documentation

◆ allocator_type

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

export the allocator type

◆ const_iterator

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

make iterators available as types

◆ difference_type

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

The type used for the difference between two iterator positions.

◆ iterator

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

make iterators available as types

◆ member_type

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

export the type representing the components

◆ size_type

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

The type used for the index access.

Constructor & Destructor Documentation

◆ base_array() [1/4]

template<class B , class A = std::allocator<B>>
Dune::base_array< B, A >::base_array ( )
inline

makes empty array

◆ base_array() [2/4]

template<class B , class A = std::allocator<B>>
Dune::base_array< B, A >::base_array ( size_type  _n)
inline

make array with _n components

◆ base_array() [3/4]

template<class B , class A = std::allocator<B>>
Dune::base_array< B, A >::base_array ( const base_array< B, A > &  a)
inline

copy constructor

◆ base_array() [4/4]

template<class B , class A = std::allocator<B>>
Dune::base_array< B, A >::base_array ( const base_array_unmanaged< B, A > &  _a)
inline

construct from base class object

◆ ~base_array()

template<class B , class A = std::allocator<B>>
Dune::base_array< B, A >::~base_array ( )
inline

free dynamic memory

Member Function Documentation

◆ beforeBegin() [1/2]

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

◆ beforeBegin() [2/2]

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

◆ beforeEnd() [1/2]

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

◆ beforeEnd() [2/2]

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

◆ begin() [1/2]

template<class B , class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::begin ( )
inlineinherited

begin iterator

◆ begin() [2/2]

template<class B , class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::begin ( ) const
inlineinherited

begin const_iterator

◆ end() [1/2]

template<class B , class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::end ( )
inlineinherited

end iterator

◆ end() [2/2]

template<class B , class A = std::allocator<B>>
const_iterator Dune::base_array_unmanaged< B, A >::end ( ) const
inlineinherited

end const_iterator

◆ find() [1/2]

template<class B , class A = std::allocator<B>>
iterator Dune::base_array_unmanaged< B, A >::find ( size_type  i)
inlineinherited

random access returning iterator (end if not contained)

◆ find() [2/2]

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

random access returning iterator (end if not contained)

◆ operator=() [1/2]

template<class B , class A = std::allocator<B>>
base_array & Dune::base_array< B, A >::operator= ( const base_array< B, A > &  a)
inline

assignment

◆ operator=() [2/2]

template<class B , class A = std::allocator<B>>
base_array & Dune::base_array< B, A >::operator= ( const base_array_unmanaged< B, A > &  a)
inline

assign from base class object

◆ operator[]() [1/2]

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

random access to blocks

◆ operator[]() [2/2]

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

same for read only access

◆ resize()

template<class B , class A = std::allocator<B>>
void Dune::base_array< B, A >::resize ( size_type  _n)
inline

reallocate array to given size, any data is lost

◆ size()

template<class B , class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::size ( ) const
inlineinherited

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

Member Data Documentation

◆ allocator_

template<class B , class A = std::allocator<B>>
A Dune::base_array< B, A >::allocator_
protected

◆ n

template<class B , class A = std::allocator<B>>
size_type Dune::base_array_unmanaged< B, A >::n
protectedinherited

◆ p

template<class B , class A = std::allocator<B>>
B* Dune::base_array_unmanaged< B, A >::p
protectedinherited

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