Rosetta 3.3
Public Types | Public Member Functions | Public Attributes | Friends
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 >:
Inheritance graph
[legend]
Collaboration diagram for utility::vectorL< L, bool, A >:
Collaboration graph
[legend]

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.
vectorLoperator= (vectorL const &v)
 Copy assignment.
template<ssize_type L_, typename T_ , typename A_ >
vectorLoperator= (vectorL< L_, T_, A_ > const &v)
 Assignable copy assignment.
vectorLoperator= (super const &v)
 std::vector assignment
template<typename T_ , typename A_ >
vectorLoperator= (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]
template<ssize_t L, typename A >
reference utility::vectorL< L, bool, A >::operator[] ( index_type const  i) [inline]
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]
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]
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]
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]
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]
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]
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]
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:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines