[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]

| MultiArray Class Template Reference |
--- | --- | ---

Main `MultiArray` class containing the memory management. More...

`#include "vigra/multi_array.hxx"`

Inheritance diagram for MultiArray:

## Public Types
typedef A | allocator_type
typedef MultiArrayView< N, T > | view_type
typedef MultiArray< N, T, A > | matrix_type
typedef view_type::value_type | value_type
typedef view_type::pointer | pointer
typedef view_type::const_pointer | const_pointer
typedef view_type::reference | reference
typedef view_type::const_reference | const_reference
typedef view_type::size_type | size_type
typedef view_type::difference_type | difference_type
typedef detail::MultiIteratorChooser< UnstridedArrayTag >::template Traverser< N, T, T &, T * >::type | traverser
typedef detail::MultiIteratorChooser< UnstridedArrayTag >::template Traverser< N, T, T const &, T const * >::type | const_traverser
typedef T * | iterator
typedef T * | const_iterator
## Public Methods
| MultiArray ()
| MultiArray (allocator_type const &alloc)
| MultiArray (const difference_type &shape, allocator_type const &alloc=allocator_type())
| MultiArray (const difference_type &shape, const_reference init, allocator_type const &alloc=allocator_type())
| MultiArray (const difference_type &shape, const_pointer init, allocator_type const &alloc=allocator_type())
| MultiArray (const MultiArray &rhs)
template<class U, class C> | MultiArray (const MultiArrayView< N, U, C > &rhs, allocator_type const &alloc=allocator_type())
MultiArray & | operator= (const MultiArray &rhs)
template<class U, class C> MultiArray & | operator= (const MultiArrayView< N, U, C > &rhs)
| ~MultiArray ()
void | reshape (const difference_type &shape)
void | reshape (const difference_type &shape, const_reference init)
void | swap (MultiArray &other)
iterator | begin ()
iterator | end ()
const_iterator | begin () const
const_iterator | end () const
allocator_type const & | allocator () const
## Protected Methods
void | allocate (pointer &ptr, std::size_t s, const_reference init)
template<class U> void | allocate (pointer &ptr, std::size_t s, U const *init)
template<class U, class C> void | allocate (pointer &ptr, MultiArrayView< N, U, C > const &init)
void | deallocate (pointer &ptr, std::size_t s)
## Protected Attributes
allocator_type | m_alloc

## Detailed Description

### template<unsigned int N, class T, class A>
class vigra::MultiArray< N, T, A >

Main `MultiArray` class containing the memory management.

This class inherits the interface of MultiArrayView, and implements the memory ownership. MultiArray's are always unstrided, striding them creates a MultiArrayView.

The template parameters are as follows

        N: the array dimension

        T: the type of the array elements

        A: the allocator used for internal storage management
           (default: std::allocator<T>)

#include "vigra/multi_array.hxx"

Namespace: vigra

## Member Typedef Documentation

typedef A allocator_type

| the allocator type used to allocate the memory Reimplemented in Matrix.

typedef T* const_iterator

| sequential (random access) const iterator type

typedef view_type::const_pointer const_pointer

| const pointer type Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef view_type::const_reference const_reference

| const reference type (result of operator[] const) Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef detail::MultiIteratorChooser< UnstridedArrayTag>::template Traverser<N, T, T const &, T const *>::type const_traverser

| traverser type to const data Reimplemented from MultiArrayView< N, T >.

typedef view_type::difference_type difference_type

| difference type (used for offsetting) Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef T* iterator

| sequential (random access) iterator type

typedef MultiArray<N, T, A> matrix_type

| the matrix type associated with this array. Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef view_type::pointer pointer

| pointer type Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef view_type::reference reference

| reference type (result of operator[]) Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef view_type::size_type size_type

| size type Reimplemented from MultiArrayView< N, T >.

typedef detail::MultiIteratorChooser< UnstridedArrayTag>::template Traverser<N, T, T &, T *>::type traverser

| traverser type Reimplemented from MultiArrayView< N, T >.

typedef view_type::value_type value_type

| the array's value type Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

typedef MultiArrayView<N, T> view_type

| the view type associated with this array. Reimplemented from MultiArrayView< N, T >. Reimplemented in Matrix.

## Constructor & Destructor Documentation

MultiArray | ( |  | ) |

| default constructor

MultiArray | ( | allocator_type const & | alloc | ) |

| construct with given allocator

MultiArray | ( | const difference_type & | shape,
|  | allocator_type const & | alloc = allocator_type()
| ) | `[explicit]`

| construct with given shape

MultiArray | ( | const difference_type & | shape,
|  | const_reference | init,
|  | allocator_type const & | alloc = allocator_type()
| ) |

| construct from shape with an initial value

MultiArray | ( | const difference_type & | shape,
|  | const_pointer | init,
|  | allocator_type const & | alloc = allocator_type()
| ) |

| construct from shape and copy values from the given array

MultiArray | ( | const MultiArray< N, T, A > & | rhs | ) |

| copy constructor

MultiArray | ( | const MultiArrayView< N, U, C > & | rhs,
|  | allocator_type const & | alloc = allocator_type()
| ) |

| construct by copying from a MultiArrayView

~MultiArray | ( |  | ) |

| destructor

## Member Function Documentation

void allocate | ( | pointer & | ptr,
|  | MultiArrayView< N, U, C > const & | init
| ) | `[protected]`

| allocate memory, write its address into the given pointer and initialize it by copying the data from the given MultiArrayView.

void allocate | ( | pointer & | ptr,
|  | std::size_t | s,
|  | U const * | init
| ) | `[protected]`

| allocate memory for s pixels, write its address into the given pointer and initialize the linearized pixels to the values of init.

void allocate | ( | pointer & | ptr,
|  | std::size_t | s,
|  | const_reference | init
| ) | `[protected]`

| allocate memory for s pixels, write its address into the given pointer and initialize the pixels with init.

allocator_type const& allocator | ( |  | ) | const`[inline]`

| get the allocator.

const_iterator begin | ( |  | ) | const`[inline]`

| sequential const iterator pointing to the first array element.

iterator begin | ( |  | ) | `[inline]`

| sequential iterator pointing to the first array element.

void deallocate | ( | pointer & | ptr,
|  | std::size_t | s
| ) | `[protected]`

| deallocate the memory (of length s) starting at the given address.

const_iterator end | ( |  | ) | const`[inline]`

| sequential const iterator pointing beyond the last array element.

iterator end | ( |  | ) | `[inline]`

| sequential iterator pointing beyond the last array element.

MultiArray< N, T, A > & operator= | ( | const MultiArrayView< N, U, C > & | rhs | ) |

| assignment from arbitrary MultiArrayView. If the size of rhs is the same as the left-hand side arrays's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the lhs array.

MultiArray& operator= | ( | const MultiArray< N, T, A > & | rhs | ) | `[inline]`

| assignment. If the size of rhs is the same as the left-hand side arrays's old size, only the data are copied. Otherwise, new storage is allocated, which invalidates all objects (array views, iterators) depending on the lhs array.

void reshape | ( | const difference_type & | shape,
|  | const_reference | init
| ) |

| change the shape, allocate new memory and initialize it with the given value. Note: this operation invalidates all dependent objects (array views and iterators)

void reshape | ( | const difference_type & | shape | ) | `[inline]`

| change the shape and allocate new memory. Note: this operation invalidates all dependent objects (array views and iterators)

void swap | ( | MultiArray< N, T, A > & | other | ) |

| Swap the contents with another MultiArray. This is fast, because no data are copied, but only pointers and shapes swapped. Note: this operation invalidates all dependent objects (array views and iterators)

## Member Data Documentation

allocator_type m_alloc`[protected]`

| the allocator used to allocate the memory

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

- vigra/multi_array.hxx

© Ullrich Köthe (koethe@informatik.uni-hamburg.de) Cognitive Systems Group, University of Hamburg, Germany | html generated using doxygen and Python VIGRA 1.3.2 (27 Jan 2005)