utility::vectorL< L, bool, A > Class Template Reference

std::vector with L-based indexing: bool specialization More...

#include <vectorL_bool.hh>

Inheritance diagram for utility::vectorL< L, bool, A >:

Collaboration diagram for utility::vectorL< L, bool, A >:

List of all members.

Public Types
typedef super::value_type	value_type
typedef super::reference	reference
typedef super::const_reference	const_reference
typedef super::pointer	pointer
typedef super::const_pointer	const_pointer
typedef super::iterator	iterator
typedef super::const_iterator	const_iterator
typedef super::reverse_iterator	reverse_iterator
typedef super::const_reverse_iterator	const_reverse_iterator
typedef super::size_type	size_type
typedef super::difference_type	difference_type
typedef super::allocator_type	allocator_type
typedef ssize_t	ssize_type
typedef super::value_type	Value
typedef super::reference	Reference
typedef super::const_reference	ConstReference
typedef super::pointer	Pointer
typedef super::const_pointer	ConstPointer
typedef super::iterator	Iterator
typedef super::const_iterator	ConstIterator
typedef super::reverse_iterator	ReverseIterator
typedef super::const_reverse_iterator	ConstReverseIterator
typedef super::size_type	Size
typedef super::difference_type	Difference
typedef super::allocator_type	Allocator
typedef platform::SSize	SSize
Public Member Functions
	vectorL (allocator_type const &alloc=allocator_type())
	Default constructor.
	vectorL (vectorL const &v)
	Copy constructor.
template<ssize_type L_, typename T_ , typename A_ >
	vectorL (vectorL< L_, T_, A_ > const &v)
	Assignable copy constructor.
	vectorL (super const &v)
	std::vector constructor
template<typename T_ , typename A_ >
	vectorL (std::vector< T_, A_ > const &v)
	Assignable std::vector constructor.
	vectorL (size_type const num)
	Size constructor.
	vectorL (size_type const num, value_type const &value, allocator_type const &alloc=allocator_type())
	Uniform value constructor.
template<typename InputIterator >
	vectorL (InputIterator const beg, InputIterator const end, allocator_type const &alloc=allocator_type())
	Iterator range constructor.
virtual	~vectorL ()
	Destructor.
vectorL &	operator= (vectorL const &v)
	Copy assignment.
template<ssize_type L_, typename T_ , typename A_ >
vectorL &	operator= (vectorL< L_, T_, A_ > const &v)
	Assignable copy assignment.
vectorL &	operator= (super const &v)
	std::vector assignment
template<typename T_ , typename A_ >
vectorL &	operator= (std::vector< T_, A_ > const &v)
	Assignable std::vector assignment.
super const &	vector () const
	std::vector const explicit conversion
super &	vector ()
	std::vector explicit conversion
void	shrink ()
	Shrink the index map to remove unused capacity.
bool	has (index_type const i) const
	Has an element with an index?
const_reference	operator[] (index_type const i) const
	vectorL[ i ] const
reference	operator[] (index_type const i)
	vectorL[ i ]
const_reference	at (index_type const i) const
	vectorL.at( i ) const
reference	at (index_type const i)
	vectorL.at( i )
index_type	l () const
	Lower index.
index_type	u () const
	Upper index.
void	swap (vectorL &v)
	swap( vectorL )
Public Attributes
typedef	vectorL_IndexSelector< L > = 0 >::index_type index_type
Friends
bool	operator== (vectorL const &a, vectorL const &b)
	vectorL == vectorL
bool	operator!= (vectorL const &a, vectorL const &b)
	vectorL != vectorL
bool	operator< (vectorL const &a, vectorL const &b)
	vectorL < vectorL
bool	operator<= (vectorL const &a, vectorL const &b)
	vectorL <= vectorL
bool	operator>= (vectorL const &a, vectorL const &b)
	vectorL >= vectorL
bool	operator> (vectorL const &a, vectorL const &b)
	vectorL > vectorL
bool	operator== (vectorL const &a, super const &b)
	vectorL == std::vector
bool	operator!= (vectorL const &a, super const &b)
	vectorL != std::vector
bool	operator< (vectorL const &a, super const &b)
	vectorL < std::vector
bool	operator<= (vectorL const &a, super const &b)
	vectorL <= std::vector
bool	operator>= (vectorL const &a, super const &b)
	vectorL >= std::vector
bool	operator> (vectorL const &a, super const &b)
	vectorL > std::vector
bool	operator== (super const &a, vectorL const &b)
	std::vector == vectorL
bool	operator!= (super const &a, vectorL const &b)
	std::vector != vectorL
bool	operator< (super const &a, vectorL const &b)
	std::vector < vectorL
bool	operator<= (super const &a, vectorL const &b)
	std::vector <= vectorL
bool	operator>= (super const &a, vectorL const &b)
	std::vector >= vectorL
bool	operator> (super const &a, vectorL const &b)
	std::vector > vectorL
void	swap (vectorL &a, vectorL &b)
	swap( vectorL, vectorL )
void	swap (vectorL &a, super &b)
	swap( vectorL, std::vector )
void	swap (super &a, vectorL &b)
	swap( std::vector, vectorL )

---

Detailed Description

template<ssize_t L, typename A>
class utility::vectorL< L, bool, A >

std::vector with L-based indexing: bool specialization

Note:

• std::vector with L-based indexing and a few extras
• Lower index must be in the range of ssize_t
• Index type is std::size_t or ssize_t depending on sign of L
• When L is negative indexing operators can only reach the first max( ssize_t ) element and attempting to index beyond that will trigger an assertion failure
• Can construct and assign from std::vector and swap with std::vector
• Can compare with std::vector: compares contents ignoring indexes
• Can explicitly convert to std::vector
• Private inheritance from std::vector is safe here

---

Member Typedef Documentation

template<ssize_t L, typename A >

typedef super::allocator_type utility::vectorL< L, bool, A >::Allocator

template<ssize_t L, typename A >

typedef super::allocator_type utility::vectorL< L, bool, A >::allocator_type

template<ssize_t L, typename A >

typedef super::const_iterator utility::vectorL< L, bool, A >::const_iterator

template<ssize_t L, typename A >

typedef super::const_pointer utility::vectorL< L, bool, A >::const_pointer

template<ssize_t L, typename A >

typedef super::const_reference utility::vectorL< L, bool, A >::const_reference

template<ssize_t L, typename A >

typedef super::const_reverse_iterator utility::vectorL< L, bool, A >::const_reverse_iterator

template<ssize_t L, typename A >

typedef super::const_iterator utility::vectorL< L, bool, A >::ConstIterator

template<ssize_t L, typename A >

typedef super::const_pointer utility::vectorL< L, bool, A >::ConstPointer

template<ssize_t L, typename A >

typedef super::const_reference utility::vectorL< L, bool, A >::ConstReference

template<ssize_t L, typename A >

typedef super::const_reverse_iterator utility::vectorL< L, bool, A >::ConstReverseIterator

template<ssize_t L, typename A >

typedef super::difference_type utility::vectorL< L, bool, A >::Difference

template<ssize_t L, typename A >

typedef super::difference_type utility::vectorL< L, bool, A >::difference_type

template<ssize_t L, typename A >

typedef super::iterator utility::vectorL< L, bool, A >::Iterator

template<ssize_t L, typename A >

typedef super::iterator utility::vectorL< L, bool, A >::iterator

template<ssize_t L, typename A >

typedef super::pointer utility::vectorL< L, bool, A >::Pointer

template<ssize_t L, typename A >

typedef super::pointer utility::vectorL< L, bool, A >::pointer

template<ssize_t L, typename A >

typedef super::reference utility::vectorL< L, bool, A >::reference

template<ssize_t L, typename A >

typedef super::reference utility::vectorL< L, bool, A >::Reference

template<ssize_t L, typename A >

typedef super::reverse_iterator utility::vectorL< L, bool, A >::reverse_iterator

template<ssize_t L, typename A >

typedef super::reverse_iterator utility::vectorL< L, bool, A >::ReverseIterator

template<ssize_t L, typename A >

typedef super::size_type utility::vectorL< L, bool, A >::Size

template<ssize_t L, typename A >

typedef super::size_type utility::vectorL< L, bool, A >::size_type

template<ssize_t L, typename A >

typedef platform::SSize utility::vectorL< L, bool, A >::SSize

template<ssize_t L, typename A >

typedef ssize_t utility::vectorL< L, bool, A >::ssize_type

template<ssize_t L, typename A >

typedef super::value_type utility::vectorL< L, bool, A >::Value

template<ssize_t L, typename A >

typedef super::value_type utility::vectorL< L, bool, A >::value_type

---

Constructor & Destructor Documentation

template<ssize_t L, typename A >

utility::vectorL< L, bool, A >::vectorL

(

allocator_type const &

alloc = allocator_type()

)

[inline, explicit]

Default constructor.

template<ssize_t L, typename A >

utility::vectorL< L, bool, A >::vectorL

(

vectorL< L, bool, A > const &

v

)

[inline]

Copy constructor.

template<ssize_t L, typename A >

template<ssize_type L_, typename T_ , typename A_ >

utility::vectorL< L, bool, A >::vectorL

(

vectorL< L_, T_, A_ > const &

v

)

[inline]

Assignable copy constructor.

template<ssize_t L, typename A >

utility::vectorL< L, bool, A >::vectorL

(

super const &

v

)

[inline, explicit]

std::vector constructor

template<ssize_t L, typename A >

template<typename T_ , typename A_ >

utility::vectorL< L, bool, A >::vectorL

(

std::vector< T_, A_ > const &

v

)

[inline, explicit]

Assignable std::vector constructor.

template<ssize_t L, typename A >

utility::vectorL< L, bool, A >::vectorL

(

size_type const

num

)

[inline, explicit]

Size constructor.

template<ssize_t L, typename A >

utility::vectorL< L, bool, A >::vectorL	(	size_type const	num,
		value_type const &	value,
		allocator_type const &	alloc = allocator_type()
	)		[inline]

Uniform value constructor.

template<ssize_t L, typename A >

template<typename InputIterator >

utility::vectorL< L, bool, A >::vectorL	(	InputIterator const	beg,
		InputIterator const	end,
		allocator_type const &	alloc = allocator_type()
	)		[inline]

Iterator range constructor.

template<ssize_t L, typename A >

virtual utility::vectorL< L, bool, A >::~vectorL

(

)

[inline, virtual]

Destructor.

---

Member Function Documentation

template<ssize_t L, typename A >

const_reference utility::vectorL< L, bool, A >::at

(

index_type const

i

)

const [inline]

vectorL.at( i ) const

References utility::vectorL< L, T, A >::at().

template<ssize_t L, typename A >

reference utility::vectorL< L, bool, A >::at

(

index_type const

i

)

[inline]

vectorL.at( i )

References utility::vectorL< L, T, A >::at().

template<ssize_t L, typename A >

bool utility::vectorL< L, bool, A >::has

(

index_type const

i

)

const [inline]

Has an element with an index?

References amino_acids::size.

template<ssize_t L, typename A >

index_type utility::vectorL< L, bool, A >::l

(

)

const [inline]

Lower index.

template<ssize_t L, typename A >

template<ssize_type L_, typename T_ , typename A_ >

vectorL& utility::vectorL< L, bool, A >::operator=

(

vectorL< L_, T_, A_ > const &

v

)

[inline]

Assignable copy assignment.

template<ssize_t L, typename A >

template<typename T_ , typename A_ >

vectorL& utility::vectorL< L, bool, A >::operator=

(

std::vector< T_, A_ > const &

v

)

[inline]

Assignable std::vector assignment.

template<ssize_t L, typename A >

vectorL& utility::vectorL< L, bool, A >::operator=

(

vectorL< L, bool, A > const &

v

)

[inline]

Copy assignment.

References utility::vectorL< L, T, A >::operator=().

template<ssize_t L, typename A >

vectorL& utility::vectorL< L, bool, A >::operator=

(

super const &

v

)

[inline]

std::vector assignment

References utility::vectorL< L, T, A >::operator=().

template<ssize_t L, typename A >

const_reference utility::vectorL< L, bool, A >::operator[]

(

index_type const

i

)

const [inline]

vectorL[ i ] const

References utility::vectorL< L, T, A >::operator[](), and amino_acids::size.

template<ssize_t L, typename A >

reference utility::vectorL< L, bool, A >::operator[]

(

index_type const

i

)

[inline]

vectorL[ i ]

References utility::vectorL< L, T, A >::operator[](), and amino_acids::size.

template<ssize_t L, typename A >

void utility::vectorL< L, bool, A >::shrink

(

)

[inline]

Shrink the index map to remove unused capacity.

References amino_acids::size, and utility::vectorL< L, T, A >::vectorL().

template<ssize_t L, typename A >

void utility::vectorL< L, bool, A >::swap

(

vectorL< L, bool, A > &

v

)

[inline]

swap( vectorL )

References utility::vectorL< L, T, A >::swap().

Referenced by std::swap().

template<ssize_t L, typename A >

index_type utility::vectorL< L, bool, A >::u

(

)

const [inline]

Upper index.

References basic::options::OptionKeys::score::empty, and amino_acids::size.

template<ssize_t L, typename A >

super const& utility::vectorL< L, bool, A >::vector

(

)

const [inline]

std::vector const explicit conversion

template<ssize_t L, typename A >

super& utility::vectorL< L, bool, A >::vector

(

)

[inline]

std::vector explicit conversion

---

Friends And Related Function Documentation

template<ssize_t L, typename A >

bool operator!=	(	vectorL< L, bool, A > const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

vectorL != vectorL

template<ssize_t L, typename A >

bool operator!=	(	vectorL< L, bool, A > const &	a,
		super const &	b
	)		[friend]

vectorL != std::vector

template<ssize_t L, typename A >

bool operator!=	(	super const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

std::vector != vectorL

template<ssize_t L, typename A >

bool operator<	(	vectorL< L, bool, A > const &	a,
		super const &	b
	)		[friend]

vectorL < std::vector

template<ssize_t L, typename A >

bool operator<	(	vectorL< L, bool, A > const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

vectorL < vectorL

template<ssize_t L, typename A >

bool operator<	(	super const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

std::vector < vectorL

template<ssize_t L, typename A >

bool operator<=	(	super const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

std::vector <= vectorL

template<ssize_t L, typename A >

bool operator<=	(	vectorL< L, bool, A > const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

vectorL <= vectorL

template<ssize_t L, typename A >

bool operator<=	(	vectorL< L, bool, A > const &	a,
		super const &	b
	)		[friend]

vectorL <= std::vector

template<ssize_t L, typename A >

bool operator==	(	vectorL< L, bool, A > const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

vectorL == vectorL

template<ssize_t L, typename A >

bool operator==	(	super const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

std::vector == vectorL

template<ssize_t L, typename A >

bool operator==	(	vectorL< L, bool, A > const &	a,
		super const &	b
	)		[friend]

vectorL == std::vector

template<ssize_t L, typename A >

bool operator>	(	vectorL< L, bool, A > const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

vectorL > vectorL

template<ssize_t L, typename A >

bool operator>	(	super const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

std::vector > vectorL

template<ssize_t L, typename A >

bool operator>	(	vectorL< L, bool, A > const &	a,
		super const &	b
	)		[friend]

vectorL > std::vector

template<ssize_t L, typename A >

bool operator>=	(	super const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

std::vector >= vectorL

template<ssize_t L, typename A >

bool operator>=	(	vectorL< L, bool, A > const &	a,
		vectorL< L, bool, A > const &	b
	)		[friend]

vectorL >= vectorL

template<ssize_t L, typename A >

bool operator>=	(	vectorL< L, bool, A > const &	a,
		super const &	b
	)		[friend]

vectorL >= std::vector

template<ssize_t L, typename A >

void swap	(	vectorL< L, bool, A > &	a,
		super &	b
	)		[friend]

swap( vectorL, std::vector )

template<ssize_t L, typename A >

void swap	(	vectorL< L, bool, A > &	a,
		vectorL< L, bool, A > &	b
	)		[friend]

swap( vectorL, vectorL )

template<ssize_t L, typename A >

void swap	(	super &	a,
		vectorL< L, bool, A > &	b
	)		[friend]

swap( std::vector, vectorL )

---

Member Data Documentation

template<ssize_t L, typename A >

typedef utility::vectorL< L, bool, A >::vectorL_IndexSelector< L > = 0 >::index_type index_type

---

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

• src/utility/vectorL_bool.hh