boost Namespace Reference


Classes

struct  apply
class  arg
struct  checked_deleter
struct  checked_array_deleter
struct  call_traits
struct  call_traits< T & >
struct  call_traits< T[N]>
struct  call_traits< const T[N]>
class  compressed_pair
class  compressed_pair< T, T >
class  shared_array
class  use_count_is_zero
class  counted_base
class  shared_ptr
class  reference_wrapper
class  is_reference_wrapper
class  is_reference_wrapper< reference_wrapper< T > >
class  unwrap_reference
class  unwrap_reference< reference_wrapper< T > >
struct  type
class  weak_ptr

Namespaces

namespace  _bi
namespace  _mfi
namespace  detail
namespace  details

Functions

template<class R, class F>
_bi::af0< R, F > make_adaptable (F f)
template<class F>
_bi::protected_bind_t< F > protect (F f)
template<class V, class T>
void visit_each (V &v, _bi::value< T > const &t, int)
template<class V, class R, class F, class L>
void visit_each (V &v, _bi::bind_t< R, F, L > const &t, int)
template<class R, class F>
_bi::bind_t< R, F, _bi::list0 > BOOST_BIND (F f)
template<class R, class F, class A1>
_bi::bind_t< R, F, typename
_bi::list_av_1< A1 >::type > 		BOOST_BIND (F f, A1 a1)
template<class R, class F, class A1, class A2>
_bi::bind_t< R, F, typename
_bi::list_av_2< A1, A2
>::type > 		BOOST_BIND (F f, A1 a1, A2 a2)
template<class R, class F, class A1, class A2, class A3>
_bi::bind_t< R, F, typename
_bi::list_av_3< A1, A2, A3
>::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3)
template<class R, class F, class A1, class A2, class A3, class A4>
_bi::bind_t< R, F, typename
_bi::list_av_4< A1, A2, A3,
A4 >::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4)
template<class R, class F, class A1, class A2, class A3, class A4, class A5>
_bi::bind_t< R, F, typename
_bi::list_av_5< A1, A2, A3,
A4, A5 >::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t< R, F, typename
_bi::list_av_6< A1, A2, A3,
A4, A5, A6 >::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t< R, F, typename
_bi::list_av_7< A1, A2, A3,
A4, A5, A6, A7 >::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t< R, F, typename
_bi::list_av_8< A1, A2, A3,
A4, A5, A6, A7, A8 >::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t< R, F, typename
_bi::list_av_9< A1, A2, A3,
A4, A5, A6, A7, A8, A9
>::type > 		BOOST_BIND (F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
template<class R, class T, class A1>
_bi::bind_t< R const &, _mfi::dm<
R, T >, typename _bi::list_av_1<
A1 >::type > 		BOOST_BIND (R T::*f, A1 a1)
template<typename T>
void checked_delete (T *x)
template<typename T>
void checked_array_delete (T *x)
template<typename Iter1, typename Iter2>
Iter1 begin (const std::pair< Iter1, Iter2 > &p)
template<typename Iter1, typename Iter2>
Iter2 end (const std::pair< Iter1, Iter2 > &p)
template<typename Iter1, typename Iter2>
boost::detail::iterator_traits<
Iter1 >::difference_type 		size (const std::pair< Iter1, Iter2 > &p)
template<typename T>
std::vector< T >::iterator begin (std::vector< T > &c)
template<typename T>
std::vector< T >::const_iterator begin (const std::vector< T > &c)
template<typename T>
std::vector< T >::iterator end (std::vector< T > &c)
template<typename T>
std::vector< T >::const_iterator end (const std::vector< T > &c)
template<typename T>
std::vector< T >::size_type size (const std::vector< T > &c)
template<class ForwardIterator, class T>
void iota (ForwardIterator first, ForwardIterator last, T value)
template<typename Container, typename T>
void iota (Container &c, const T &value)
template<typename Container, typename OutIter>
OutIter copy (const Container &c, OutIter result)
template<typename Container1, typename Container2>
bool equal (const Container1 &c1, const Container2 &c2)
template<typename Container>
void sort (Container &c)
template<typename Container, typename Predicate>
void sort (Container &c, const Predicate &p)
template<typename Container>
void stable_sort (Container &c)
template<typename Container, typename Predicate>
void stable_sort (Container &c, const Predicate &p)
template<typename InputIterator, typename Predicate>
bool any_if (InputIterator first, InputIterator last, Predicate p)
template<typename Container, typename Predicate>
bool any_if (const Container &c, Predicate p)
template<typename InputIterator, typename T>
bool contains (InputIterator first, InputIterator last, T value)
template<typename Container, typename T>
bool contains (const Container &c, const T &value)
template<typename InputIterator, typename Predicate>
bool all (InputIterator first, InputIterator last, Predicate p)
template<typename Container, typename Predicate>
bool all (const Container &c, Predicate p)
template<typename InputIterator, typename Predicate>
bool none (InputIterator first, InputIterator last, Predicate p)
template<typename Container, typename Predicate>
bool none (const Container &c, Predicate p)
template<typename Container, typename T>
std::size_t count (const Container &c, const T &value)
template<typename Container, typename Predicate>
std::size_t count_if (const Container &c, Predicate p)
template<typename ForwardIterator>
bool is_sorted (ForwardIterator first, ForwardIterator last)
template<typename ForwardIterator, typename StrictWeakOrdering>
bool is_sorted (ForwardIterator first, ForwardIterator last, StrictWeakOrdering comp)
template<typename Container>
bool is_sorted (const Container &c)
template<typename Container, typename StrictWeakOrdering>
bool is_sorted (const Container &c, StrictWeakOrdering comp)
template<class Generator>
int catch_exceptions (Generator function_object, std::ostream &out, std::ostream &err)
template<class T1, class T2>
void swap (compressed_pair< T1, T2 > &x, compressed_pair< T1, T2 > &y)
int report_errors ()
template<class T, class U>
bool operator== (shared_array< T > const &a, shared_array< U > const &b)
template<class T, class U>
bool operator!= (shared_array< T > const &a, shared_array< U > const &b)
template<class T>
bool operator< (shared_array< T > const &a, shared_array< T > const &b)
template<class T>
void swap (shared_array< T > &a, shared_array< T > &b)
void intrusive_ptr_add_ref (counted_base *p)
void intrusive_ptr_release (counted_base *p)
template<class T, class U>
bool operator== (shared_ptr< T > const &a, shared_ptr< U > const &b)
template<class T, class U>
bool operator!= (shared_ptr< T > const &a, shared_ptr< U > const &b)
template<class T>
bool operator< (shared_ptr< T > const &a, shared_ptr< T > const &b)
template<class T>
void swap (shared_ptr< T > &a, shared_ptr< T > &b)
template<class T>
T * get_pointer (shared_ptr< T > const &p)
template<class T>
T * get_pointer (T *p)
template<class R, class T>
_mfi::dm< R, T > mem_fn (R T::*f)
template<class T>
reference_wrapper< T > BOOST_REF_CONST ref (T &t)
template<class T>
reference_wrapper< T const
> BOOST_REF_CONST 		cref (T const &t)
template<typename T, typename U>
shared_ptr< T > shared_static_cast (shared_ptr< U > const &r)
template<typename T, typename U>
shared_ptr< T > shared_dynamic_cast (shared_ptr< U > const &r)
template<typename T, typename U>
shared_ptr< T > shared_polymorphic_cast (shared_ptr< U > const &r)
template<typename T, typename U>
shared_ptr< T > shared_polymorphic_downcast (shared_ptr< U > const &r)
template<class T>
shared_ptr< T > shared_from_this (T *p)
template<class E>
void throw_exception (E const &e)
template<typename T>
T * addressof (T &v)
template<class T, class U>
bool operator== (weak_ptr< T > const &a, weak_ptr< U > const &b)
template<class T, class U>
bool operator!= (weak_ptr< T > const &a, weak_ptr< U > const &b)
template<class T>
bool operator< (weak_ptr< T > const &a, weak_ptr< T > const &b)
template<class T>
void swap (weak_ptr< T > &a, weak_ptr< T > &b)
template<class T>
shared_ptr< T > make_shared (weak_ptr< T > const &r)

Function Documentation

template<typename T>
T* boost::addressof ( T &  v  ) 

template<typename Container, typename Predicate>
bool boost::all ( const Container &  c,
Predicate  p 
)

template<typename InputIterator, typename Predicate>
bool boost::all ( InputIterator  first,
InputIterator  last,
Predicate  p 
)

template<typename Container, typename Predicate>
bool boost::any_if ( const Container &  c,
Predicate  p 
)

template<typename InputIterator, typename Predicate>
bool boost::any_if ( InputIterator  first,
InputIterator  last,
Predicate  p 
)

template<typename T>
std::vector<T>::const_iterator boost::begin ( const std::vector< T > &  c  ) 

template<typename T>
std::vector<T>::iterator boost::begin ( std::vector< T > &  c  ) 

template<typename Iter1, typename Iter2>
Iter1 boost::begin ( const std::pair< Iter1, Iter2 > &  p  ) 

template<class R, class T, class A1>
_bi::bind_t< R const &, _mfi::dm<R, T>, typename _bi::list_av_1<A1>::type > boost::BOOST_BIND ( R T::*  f,
A1  a1 
)

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3,
A4  a4,
A5  a5,
A6  a6,
A7  a7,
A8  a8,
A9  a9 
)

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_8< A1, A2, A3, A4, A5, A6, A7, A8 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3,
A4  a4,
A5  a5,
A6  a6,
A7  a7,
A8  a8 
)

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_7< A1, A2, A3, A4, A5, A6, A7 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3,
A4  a4,
A5  a5,
A6  a6,
A7  a7 
)

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_6< A1, A2, A3, A4, A5, A6 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3,
A4  a4,
A5  a5,
A6  a6 
)

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_5< A1, A2, A3, A4, A5 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3,
A4  a4,
A5  a5 
)

template<class R, class F, class A1, class A2, class A3, class A4>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_4< A1, A2, A3, A4 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3,
A4  a4 
)

template<class R, class F, class A1, class A2, class A3>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_3< A1, A2, A3 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2,
A3  a3 
)

template<class R, class F, class A1, class A2>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_2< A1, A2 >::type > boost::BOOST_BIND ( F  f,
A1  a1,
A2  a2 
)

template<class R, class F, class A1>
_bi::bind_t< _bi::unspecified, F, typename _bi::list_av_1< A1 >::type > boost::BOOST_BIND ( F  f,
A1  a1 
)

template<class R, class F>
_bi::bind_t< _bi::unspecified, F, _bi::list0 > boost::BOOST_BIND ( F  f  ) 

template<class Generator>
int boost::catch_exceptions ( Generator  function_object,
std::ostream &  out,
std::ostream &  err 
)

template<typename T>
void boost::checked_array_delete ( T *  x  )  [inline]

template<typename T>
void boost::checked_delete ( T *  x  )  [inline]

template<typename Container, typename T>
bool boost::contains ( const Container &  c,
const T &  value 
)

template<typename InputIterator, typename T>
bool boost::contains ( InputIterator  first,
InputIterator  last,
T  value 
)

template<typename Container, typename OutIter>
OutIter boost::copy ( const Container &  c,
OutIter  result 
)

template<typename Container, typename T>
std::size_t boost::count ( const Container &  c,
const T &  value 
)

template<typename Container, typename Predicate>
std::size_t boost::count_if ( const Container &  c,
Predicate  p 
)

template<class T>
reference_wrapper<T const> BOOST_REF_CONST boost::cref ( T const &  t  )  [inline]

template<typename T>
std::vector<T>::const_iterator boost::end ( const std::vector< T > &  c  ) 

template<typename T>
std::vector<T>::iterator boost::end ( std::vector< T > &  c  ) 

template<typename Iter1, typename Iter2>
Iter2 boost::end ( const std::pair< Iter1, Iter2 > &  p  ) 

template<typename Container1, typename Container2>
bool boost::equal ( const Container1 &  c1,
const Container2 &  c2 
)

template<class T>
T* boost::get_pointer ( T *  p  ) 

template<class T>
T * boost::get_pointer ( shared_ptr< T > const &  p  )  [inline]

void boost::intrusive_ptr_add_ref ( counted_base *  p  )  [inline]

void boost::intrusive_ptr_release ( counted_base *  p  )  [inline]

template<typename Container, typename T>
void boost::iota ( Container &  c,
const T &  value 
)

template<class ForwardIterator, class T>
void boost::iota ( ForwardIterator  first,
ForwardIterator  last,
T  value 
)

template<typename Container, typename StrictWeakOrdering>
bool boost::is_sorted ( const Container &  c,
StrictWeakOrdering  comp 
)

template<typename Container>
bool boost::is_sorted ( const Container &  c  ) 

template<typename ForwardIterator, typename StrictWeakOrdering>
bool boost::is_sorted ( ForwardIterator  first,
ForwardIterator  last,
StrictWeakOrdering  comp 
)

template<typename ForwardIterator>
bool boost::is_sorted ( ForwardIterator  first,
ForwardIterator  last 
)

template<class R, class F>
_bi::af4< R, A1, A2, A3, A4, F > boost::make_adaptable ( F  f  ) 

template<class T>
shared_ptr<T> boost::make_shared ( weak_ptr< T > const &  r  ) 

template<class R, class T>
_mfi::dm<R, T> boost::mem_fn ( R T::*  f  ) 

template<typename Container, typename Predicate>
bool boost::none ( const Container &  c,
Predicate  p 
)

template<typename InputIterator, typename Predicate>
bool boost::none ( InputIterator  first,
InputIterator  last,
Predicate  p 
)

template<class T, class U>
bool boost::operator!= ( weak_ptr< T > const &  a,
weak_ptr< U > const &  b 
) [inline]

template<class T, class U>
bool boost::operator!= ( shared_ptr< T > const &  a,
shared_ptr< U > const &  b 
) [inline]

template<class T, class U>
bool boost::operator!= ( shared_array< T > const &  a,
shared_array< U > const &  b 
) [inline]

template<class T>
bool boost::operator< ( weak_ptr< T > const &  a,
weak_ptr< T > const &  b 
) [inline]

template<class T>
bool boost::operator< ( shared_ptr< T > const &  a,
shared_ptr< T > const &  b 
) [inline]

template<class T>
bool boost::operator< ( shared_array< T > const &  a,
shared_array< T > const &  b 
) [inline]

template<class T, class U>
bool boost::operator== ( weak_ptr< T > const &  a,
weak_ptr< U > const &  b 
) [inline]

template<class T, class U>
bool boost::operator== ( shared_ptr< T > const &  a,
shared_ptr< U > const &  b 
) [inline]

template<class T, class U>
bool boost::operator== ( shared_array< T > const &  a,
shared_array< U > const &  b 
) [inline]

template<class F>
_bi::protected_bind_t<F> boost::protect ( F  f  ) 

template<class T>
reference_wrapper<T> BOOST_REF_CONST boost::ref ( T &  t  )  [inline]

int boost::report_errors (  )  [inline]

template<typename T, typename U>
shared_ptr<T> boost::shared_dynamic_cast ( shared_ptr< U > const &  r  ) 

template<class T>
shared_ptr<T> boost::shared_from_this ( T *  p  ) 

template<typename T, typename U>
shared_ptr<T> boost::shared_polymorphic_cast ( shared_ptr< U > const &  r  ) 

template<typename T, typename U>
shared_ptr<T> boost::shared_polymorphic_downcast ( shared_ptr< U > const &  r  ) 

template<typename T, typename U>
shared_ptr<T> boost::shared_static_cast ( shared_ptr< U > const &  r  ) 

template<typename T>
std::vector<T>::size_type boost::size ( const std::vector< T > &  c  ) 

template<typename Iter1, typename Iter2>
boost::detail::iterator_traits<Iter1>::difference_type boost::size ( const std::pair< Iter1, Iter2 > &  p  ) 

template<typename Container, typename Predicate>
void boost::sort ( Container &  c,
const Predicate &  p 
)

template<typename Container>
void boost::sort ( Container &  c  ) 

template<typename Container, typename Predicate>
void boost::stable_sort ( Container &  c,
const Predicate &  p 
)

template<typename Container>
void boost::stable_sort ( Container &  c  ) 

template<class T>
void boost::swap ( weak_ptr< T > &  a,
weak_ptr< T > &  b 
)

template<class T>
void boost::swap ( shared_ptr< T > &  a,
shared_ptr< T > &  b 
) [inline]

template<class T>
void boost::swap ( shared_array< T > &  a,
shared_array< T > &  b 
)

template<class T1, class T2>
void boost::swap ( compressed_pair< T1, T2 > &  x,
compressed_pair< T1, T2 > &  y 
) [inline]

template<class E>
void boost::throw_exception ( E const &  e  ) 

template<class V, class R, class F, class L>
void boost::visit_each ( V &  v,
_bi::bind_t< R, F, L > const &  t,
int   
)

template<class V, class T>
void boost::visit_each ( V &  v,
_bi::value< T > const &  t,
int   
)

Generated on Wed Apr 25 13:53:29 2007 for SystemC by  doxygen 1.5.1