Rosetta 3.3
Classes | Namespaces | Functions
src/utility/vectorL.hh File Reference

vectorL: std::vector with L-based indexing More...

#include <utility/vectorL.fwd.hh>
#include <utility/vectorL_Selector.hh>
#include <cassert>
#include <vector>
#include <utility/vectorL_bool.hh>

Classes

class  utility::vectorL< L, T, A >
 std::vector with L-based indexing More...

Namespaces

namespace  utility
 

unresizable vector whose size is known at compile time, which may be allocated on the stack, and which indexes from 1.


namespace  std
 

STL namespace.


Functions

template<ssize_t L, typename T , typename A >
bool utility::operator== (vectorL< L, T, A > const &a, vectorL< L, T, A > const &b)
 vectorL == vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator!= (vectorL< L, T, A > const &a, vectorL< L, T, A > const &b)
 vectorL != vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator< (vectorL< L, T, A > const &a, vectorL< L, T, A > const &b)
 vectorL < vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator<= (vectorL< L, T, A > const &a, vectorL< L, T, A > const &b)
 vectorL <= vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator>= (vectorL< L, T, A > const &a, vectorL< L, T, A > const &b)
 vectorL >= vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator> (vectorL< L, T, A > const &a, vectorL< L, T, A > const &b)
 vectorL > vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator== (vectorL< L, T, A > const &a, std::vector< T, A > const &b)
 vectorL == std::vector
template<ssize_t L, typename T , typename A >
bool utility::operator!= (vectorL< L, T, A > const &a, std::vector< T, A > const &b)
 vectorL != std::vector
template<ssize_t L, typename T , typename A >
bool utility::operator< (vectorL< L, T, A > const &a, std::vector< T, A > const &b)
 vectorL < std::vector
template<ssize_t L, typename T , typename A >
bool utility::operator<= (vectorL< L, T, A > const &a, std::vector< T, A > const &b)
 vectorL <= std::vector
template<ssize_t L, typename T , typename A >
bool utility::operator>= (vectorL< L, T, A > const &a, std::vector< T, A > const &b)
 vectorL >= std::vector
template<ssize_t L, typename T , typename A >
bool utility::operator> (vectorL< L, T, A > const &a, std::vector< T, A > const &b)
 vectorL > std::vector
template<ssize_t L, typename T , typename A >
bool utility::operator== (std::vector< T, A > const &a, vectorL< L, T, A > const &b)
 std::vector == vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator!= (std::vector< T, A > const &a, vectorL< L, T, A > const &b)
 std::vector != vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator< (std::vector< T, A > const &a, vectorL< L, T, A > const &b)
 std::vector < vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator<= (std::vector< T, A > const &a, vectorL< L, T, A > const &b)
 std::vector <= vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator>= (std::vector< T, A > const &a, vectorL< L, T, A > const &b)
 std::vector >= vectorL
template<ssize_t L, typename T , typename A >
bool utility::operator> (std::vector< T, A > const &a, vectorL< L, T, A > const &b)
 std::vector > vectorL
template<ssize_t L, typename T , typename A >
void utility::swap (vectorL< L, T, A > &a, vectorL< L, T, A > &b)
 swap( vectorL, vectorL )
template<ssize_t L, typename T , typename A >
void utility::swap (vectorL< L, T, A > &a, std::vector< T, A > &b)
 swap( vectorL, std::vector )
template<ssize_t L, typename T , typename A >
void utility::swap (std::vector< T, A > &a, vectorL< L, T, A > &b)
 swap( std::vector, vectorL )
template<ssize_t L, typename T , typename A >
void std::swap (utility::vectorL< L, T, A > &a, utility::vectorL< L, T, A > &b)
 swap( vectorL, vectorL )
template<ssize_t L, typename T , typename A >
void std::swap (utility::vectorL< L, T, A > &a, std::vector< T, A > &b)
 swap( vectorL, std::vector )
template<ssize_t L, typename T , typename A >
void std::swap (std::vector< T, A > &a, utility::vectorL< L, T, A > &b)
 swap( std::vector, vectorL )

Detailed Description

vectorL: std::vector with L-based indexing

Author:
Stuart G. Mentzer (Stuart_Mentzer@objexx.com)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines