#include <Swapping_Vector_defs.hh>

Inheritance diagram for Parma_Polyhedra_Library::Swapping_Vector< T >:

[legend]

Public Types
typedef std::vector< T >::const_iterator	const_iterator

typedef std::vector< T >::iterator	iterator

typedef std::vector< T >::size_type	size_type

Public Member Functions
	Swapping_Vector ()

	Swapping_Vector (dimension_type new_size)

	Swapping_Vector (dimension_type new_size, const T &x)

void	clear ()

void	reserve (dimension_type new_capacity)

void	resize (dimension_type new_size)

void	resize (dimension_type new_size, const T &x)

dimension_type	size () const

dimension_type	capacity () const

bool	empty () const

void	m_swap (Swapping_Vector &v)

T &	operator[] (dimension_type i)

const T &	operator[] (dimension_type i) const

T &	back ()

const T &	back () const

void	push_back (const T &x)

void	pop_back ()

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

iterator	erase (iterator itr)

iterator	erase (iterator first, iterator last)

memory_size_type	external_memory_in_bytes () const

dimension_type	max_num_rows ()

Private Attributes
std::vector< T >	impl

Related Functions
(Note that these are not member functions.)
template<typename T >
void	swap (Swapping_Vector< T > &x, Swapping_Vector< T > &y)

Detailed Description

template<typename T>
class Parma_Polyhedra_Library::Swapping_Vector< T >

A wrapper for std::vector that calls a swap() method instead of copying elements, when possible.

Definition at line 38 of file Swapping_Vector_defs.hh.

Member Typedef Documentation

template<typename T>

typedef std::vector<T>::const_iterator Parma_Polyhedra_Library::Swapping_Vector< T >::const_iterator

Definition at line 41 of file Swapping_Vector_defs.hh.

template<typename T>

typedef std::vector<T>::iterator Parma_Polyhedra_Library::Swapping_Vector< T >::iterator

Definition at line 42 of file Swapping_Vector_defs.hh.

template<typename T>

typedef std::vector<T>::size_type Parma_Polyhedra_Library::Swapping_Vector< T >::size_type

Definition at line 43 of file Swapping_Vector_defs.hh.

Constructor & Destructor Documentation

template<typename T >

Parma_Polyhedra_Library::Swapping_Vector< T >::Swapping_Vector ( )

inline

Definition at line 33 of file Swapping_Vector_inlines.hh.

34 : impl() {

35 }

Parma_Polyhedra_Library::Swapping_Vector::impl

std::vector< T > impl

Definition: Swapping_Vector_defs.hh:83

template<typename T >

Parma_Polyhedra_Library::Swapping_Vector< T >::Swapping_Vector ( dimension_type new_size )

inlineexplicit

Definition at line 39 of file Swapping_Vector_inlines.hh.

References Parma_Polyhedra_Library::Swapping_Vector< T >::resize().

   : impl() {
   // NOTE: This is not the same as constructing impl as `impl(i)', because
   // this implementation calls compute_capacity().
   resize(i);
 }

template<typename T>

Parma_Polyhedra_Library::Swapping_Vector< T >::Swapping_Vector	(	dimension_type	new_size,
		const T &	x
	)

inline

Definition at line 48 of file Swapping_Vector_inlines.hh.

References Parma_Polyhedra_Library::Swapping_Vector< T >::resize().

   : impl() {
   resize(new_size, x);
 }

Member Function Documentation

template<typename T >

T & Parma_Polyhedra_Library::Swapping_Vector< T >::back ( )

inline

Definition at line 134 of file Swapping_Vector_inlines.hh.

Referenced by Parma_Polyhedra_Library::Linear_System< Row >::merge_rows_assign().

                          {
   return impl.back();
 }

template<typename T >

const T & Parma_Polyhedra_Library::Swapping_Vector< T >::back ( ) const

inline

Definition at line 140 of file Swapping_Vector_inlines.hh.

                                {
   return impl.back();
 }

template<typename T >

Swapping_Vector< T >::iterator Parma_Polyhedra_Library::Swapping_Vector< T >::begin ( )

inline

Definition at line 170 of file Swapping_Vector_inlines.hh.

                           {
   return impl.begin();
 }

template<typename T >

Swapping_Vector< T >::const_iterator Parma_Polyhedra_Library::Swapping_Vector< T >::begin ( ) const

inline

Definition at line 182 of file Swapping_Vector_inlines.hh.

                                 {
   return impl.begin();
 }

template<typename T >

dimension_type Parma_Polyhedra_Library::Swapping_Vector< T >::capacity ( ) const

inline

Definition at line 103 of file Swapping_Vector_inlines.hh.

                                    {
   return impl.capacity();
 }

template<typename T >

void Parma_Polyhedra_Library::Swapping_Vector< T >::clear ( )

inline

Definition at line 55 of file Swapping_Vector_inlines.hh.

                           {
   impl.clear();
 }

template<typename T >

bool Parma_Polyhedra_Library::Swapping_Vector< T >::empty ( ) const

inline

Definition at line 109 of file Swapping_Vector_inlines.hh.

                                 {
   return impl.empty();
 }

template<typename T >

Swapping_Vector< T >::iterator Parma_Polyhedra_Library::Swapping_Vector< T >::end ( )

inline

Definition at line 176 of file Swapping_Vector_inlines.hh.

                         {
   return impl.end();
 }

template<typename T >

Swapping_Vector< T >::const_iterator Parma_Polyhedra_Library::Swapping_Vector< T >::end ( ) const

inline

Definition at line 188 of file Swapping_Vector_inlines.hh.

                               {
   return impl.end();
 }

template<typename T >

Swapping_Vector< T >::iterator Parma_Polyhedra_Library::Swapping_Vector< T >::erase ( iterator itr )

inline

Definition at line 194 of file Swapping_Vector_inlines.hh.

References Parma_Polyhedra_Library::swap().

                                       {
   PPL_ASSERT(itr >= begin());
   PPL_ASSERT(itr < end());
   const dimension_type old_i = itr - begin();
   dimension_type i = old_i;
   ++i;
   while (i != size()) {
     swap(impl[i-1], impl[i]);
   }
   impl.pop_back();
   return begin() + old_i;
 }

template<typename T >

Swapping_Vector< T >::iterator Parma_Polyhedra_Library::Swapping_Vector< T >::erase	(	iterator	first,
		iterator	last
	)

inline

Definition at line 209 of file Swapping_Vector_inlines.hh.

References Parma_Polyhedra_Library::swap().

                                                        {
   PPL_ASSERT(begin() <= first);
   PPL_ASSERT(first <= last);
   PPL_ASSERT(last <= end());
   const iterator old_first = first;
   typedef typename std::iterator_traits<iterator>::difference_type diff_t;
   const diff_t k = last - first;
   const dimension_type n = static_cast<dimension_type>(end() - last);
   using std::swap;
   for (dimension_type i = 0; i < n; ++i, ++first) {
     swap(*first, *(first + k));
   }
   impl.erase(end() - k, end());
   return old_first;
 }

template<typename T >

memory_size_type Parma_Polyhedra_Library::Swapping_Vector< T >::external_memory_in_bytes ( ) const

inline

Definition at line 159 of file Swapping_Vector_inlines.hh.

                                                    {
   // Estimate the size of vector.
   memory_size_type n = impl.capacity() * sizeof(T);
   for (const_iterator i = begin(), i_end = end(); i != i_end; ++i) {
     n += i->external_memory_in_bytes();
   }
   return n;
 }

template<typename T >

void Parma_Polyhedra_Library::Swapping_Vector< T >::m_swap ( Swapping_Vector< T > & v )

inline

Definition at line 115 of file Swapping_Vector_inlines.hh.

References Parma_Polyhedra_Library::Swapping_Vector< T >::impl, and Parma_Polyhedra_Library::swap().

Referenced by Parma_Polyhedra_Library::swap().

                                              {
   using std::swap;
   swap(impl, v.impl);
 }

template<typename T >

dimension_type Parma_Polyhedra_Library::Swapping_Vector< T >::max_num_rows ( )

inline

Definition at line 227 of file Swapping_Vector_inlines.hh.

Referenced by Parma_Polyhedra_Library::Linear_System< Row >::merge_rows_assign().

                                  {
   return impl.max_size();
 }

template<typename T >

T & Parma_Polyhedra_Library::Swapping_Vector< T >::operator[] ( dimension_type i )

inline

Definition at line 122 of file Swapping_Vector_inlines.hh.

                                                {
   return impl[i];
 }

template<typename T >

const T & Parma_Polyhedra_Library::Swapping_Vector< T >::operator[] ( dimension_type i ) const

inline

Definition at line 128 of file Swapping_Vector_inlines.hh.

                                                      {
   return impl[i];
 }

template<typename T >

void Parma_Polyhedra_Library::Swapping_Vector< T >::pop_back ( )

inline

Definition at line 153 of file Swapping_Vector_inlines.hh.

                              {
   impl.pop_back();
 }

template<typename T>

void Parma_Polyhedra_Library::Swapping_Vector< T >::push_back ( const T & x )

inline

Definition at line 146 of file Swapping_Vector_inlines.hh.

                                         {
   reserve(size() + 1);
   impl.push_back(x);
 }

template<typename T >

void Parma_Polyhedra_Library::Swapping_Vector< T >::reserve ( dimension_type new_capacity )

inline

Definition at line 61 of file Swapping_Vector_inlines.hh.

References Parma_Polyhedra_Library::compute_capacity(), and Parma_Polyhedra_Library::swap().

Referenced by Parma_Polyhedra_Library::Linear_System< Row >::merge_rows_assign().

                                                        {
   if (impl.capacity() < new_capacity) {
     // Reallocation will take place.
     std::vector<T> new_impl;
 
     new_impl.reserve(compute_capacity(new_capacity, max_num_rows()));
     new_impl.resize(impl.size());
 
     using std::swap;
 
     // Steal the old elements.
     for (dimension_type i = impl.size(); i-- > 0; ) {
       swap(new_impl[i], impl[i]);
     }
 
     // Put the new vector into place.
     swap(impl, new_impl);
   }
 }

template<typename T >

void Parma_Polyhedra_Library::Swapping_Vector< T >::resize ( dimension_type new_size )

inline

Definition at line 83 of file Swapping_Vector_inlines.hh.

Referenced by Parma_Polyhedra_Library::Linear_System< Row >::Linear_System(), Parma_Polyhedra_Library::Matrix< Row >::Matrix(), Parma_Polyhedra_Library::Linear_System< Row >::merge_rows_assign(), and Parma_Polyhedra_Library::Swapping_Vector< T >::Swapping_Vector().

                                                   {
   reserve(new_size);
   impl.resize(new_size);
 }

template<typename T>

void Parma_Polyhedra_Library::Swapping_Vector< T >::resize	(	dimension_type	new_size,
		const T &	x
	)

inline

Definition at line 90 of file Swapping_Vector_inlines.hh.

                                                               {
   reserve(new_size);
   impl.resize(new_size, x);
 }

template<typename T >

dimension_type Parma_Polyhedra_Library::Swapping_Vector< T >::size ( ) const

inline

Definition at line 97 of file Swapping_Vector_inlines.hh.

Referenced by Parma_Polyhedra_Library::Matrix< Row >::Matrix(), Parma_Polyhedra_Library::Linear_System< Row >::merge_rows_assign(), Parma_Polyhedra_Library::Grid::reduce_congruence_with_equality(), and Parma_Polyhedra_Library::Grid::reduce_parameter_with_line().

                                {
   return impl.size();
 }

Friends And Related Function Documentation

template<typename T >

void swap	(	Swapping_Vector< T > &	x,
		Swapping_Vector< T > &	y
	)

                                                          {
   vec1.m_swap(vec2);
 }

Member Data Documentation

template<typename T>

std::vector<T> Parma_Polyhedra_Library::Swapping_Vector< T >::impl

private

Definition at line 83 of file Swapping_Vector_defs.hh.

Referenced by Parma_Polyhedra_Library::Swapping_Vector< T >::m_swap().

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

Public Types

Public Member Functions

Private Attributes

Related Functions

Detailed Description

template<typename T> class Parma_Polyhedra_Library::Swapping_Vector< T >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename T>
class Parma_Polyhedra_Library::Swapping_Vector< T >