alternative Standard Libary  0.29.8
Namensbereiche | Klassen | Typdefinitionen | Aufzählungen | Funktionen | Variablen
std-Namensbereichsreferenz

Namensbereiche

 graphic
 
 internal
 
 math
 
 MemoryOrder
 
 net
 
 network
 

Klassen

class  __auto_ptr_base
 
class  adler32
 
struct  aligned_as
 
struct  aligof
 
class  allocator
 
class  application
 
class  array
 
class  atomic
 
class  atomic_spinlock
 
class  auto_ptr
 
class  auto_ptr_ref
 
struct  base_vector
 
class  basic_string
 
class  basic_stringstream
 
class  bernstein
 
struct  bidirectional_iterator_tag
 
class  buffer_allocator
 
class  clone_ptr
 
class  clone_ptr_interface
 
class  Console
 
class  cow_string_storage
 
class  crc32
 
struct  default_delete
 
class  delegate
 
class  delegate_base
 
class  discard_block_engine
 
struct  equal_to
 
class  event
 
class  eventArgs
 
class  exceptionEventArgs
 
class  exitEventArgs
 
class  fast_type
 
class  fbit
 
class  filestream
 
class  fixed_array
 
class  fixed_list
 
class  fixed_sorted_vector
 
class  fixed_substring
 
class  fixed_vector
 
struct  fixed_vector_storage
 
class  fletcher16
 
class  fletcher32
 
class  fnv1a
 
struct  forward_iterator_tag
 
struct  greater
 
class  handlerEventsArgs
 
struct  has_trivial_assign
 
struct  has_trivial_constructor
 
struct  has_trivial_copy
 
struct  has_trivial_destructor
 
struct  hash
 
struct  hash< basic_string< E, TAllocator, TStorage > >
 
class  hash_map
 
class  hasher
 
class  ifstream
 
class  independent_bits_engine
 
struct  input_iterator_tag
 
class  instream
 
struct  int_to_type
 
struct  integral_constant
 
class  intrusive_list
 
class  intrusive_list_base
 
class  intrusive_list_iterator
 
struct  intrusive_list_node
 
class  intrusive_slist
 
class  intrusive_slist_base
 
class  intrusive_slist_iterator
 
struct  intrusive_slist_node
 
class  iofstream
 
struct  is_abstract
 
struct  is_class
 
struct  is_empty
 
struct  is_enum
 
struct  is_floating_point
 
struct  is_floating_point< double >
 
struct  is_floating_point< float >
 
struct  is_function
 
struct  is_fundamental
 
struct  is_integral
 
struct  is_integral< const T >
 
struct  is_integral< const volatile T >
 
struct  is_integral< volatile T >
 
struct  is_literal_type
 
struct  is_pod
 
struct  is_pod< pair< T1, T2 > >
 
struct  is_pointer
 
struct  is_pointer< T * >
 
struct  is_polymorphic
 
struct  is_rational
 
struct  is_rational< const T >
 
struct  is_rational< const volatile T >
 
struct  is_rational< volatile T >
 
struct  is_union
 
struct  is_void
 
struct  is_void< const T >
 
struct  is_void< const volatile T >
 
struct  is_void< volatile T >
 
class  isaac_engine
 
struct  iterator_traits
 
struct  iterator_traits< T * >
 
struct  less
 
class  linear_congruential_engine
 
class  list
 
class  lock_base
 abstract base class for loking Mehr ...
 
class  lock_ptr
 auto lock pointer. Mehr ...
 
class  lock_util
 lock util for auto lock and unlock. using: if(lock_util<std::mutex>(&varMutex)) { //locked } //and her unlocked Mehr ...
 
struct  make_void
 
class  map
 
class  memorystream
 
class  mersenne_twister_engine
 
class  mutex
 
class  node_ptr
 
class  object
 
class  ofstream
 
struct  output_iterator_tag
 
class  outstream
 
struct  pair
 
class  pallocator
 
class  Program
 
class  prop16_t
 
class  prop8_t
 
class  property
 
class  radix_sorter
 
class  ramakrishna
 
struct  random_access_iterator_tag
 
class  rb_tree
 
class  rb_tree_base
 
class  ring_buffer
 
class  ring_buffer_iterator
 
class  safe_counter
 safe counter is a base of thread saftly counter Mehr ...
 
class  save_ptr
 
class  scoped_ptr
 
class  shared_ptr
 
class  shuffle_order_engine
 
class  simple_string_storage
 
class  simple_wstring_storage
 
class  singleton
 
class  slist
 
class  sorted_vector
 
class  spinlock
 
class  stack
 
class  stack_allocator
 
struct  standard_vector_storage
 
class  startEventArgs
 
class  stream
 
struct  string_rep
 
class  subtract_with_carry_engine
 
class  Sys
 
class  thread
 
class  vector
 
class  weak_ptr
 
class  weinberg
 

Typdefinitionen

typedef char ERR_InvalidStringRepSize[sizeof(string_rep)==6 ? 1 :-1]
 
using fuint8_t = fast_type< 8, uint8_t >
 
using fuint16_t = fast_type< 16, uint16_t >
 
using fuint32_t = fast_type< 32, uint32_t >
 
using fuint64_t = fast_type< 64, uint64_t >
 
using fuint_least8_t = fast_type< 8, fuint_least8_t >
 
using fuint_least16_t = fast_type< 16, fuint_least16_t >
 
using fuint_least32_t = fast_type< 32, fuint_least32_t >
 
using fuint_least64_t = fast_type< 64, fuint_least64_t >
 
using fint8_t = fast_type< 8, int8_t >
 
using fint16_t = fast_type< 16, int16_t >
 
using fint32_t = fast_type< 32, int32_t >
 
using fint64_t = fast_type< 64, int64_t >
 
using fint_least8_t = fast_type< 8, fint_least8_t >
 
using fint_least16_t = fast_type< 16, fint_least16_t >
 
using fint_least32_t = fast_type< 32, fint_least32_t >
 
using fint_least64_t = fast_type< 64, fint_least64_t >
 
typedef enum std::filemode filemode_t
 
using adl32_t = adler32< 65521 >
 
using brnst_t = bernstein< 0 >
 
using flt16_t = fletcher16< 0 >
 
using flt32_t = fletcher32< 0 >
 
using fnv1a_t = fnv1a< 2166136261 >
 
using wberg_t = weinberg< 0 >
 
using crc32_t = crc32< 0x04c11db7 >
 
using crc32_k = crc32< 0x741B8CD7 >
 
using crc32_q = crc32< 0x814141AB >
 
using default_hasher = ASSTL_HASH_DEFAULT
 
typedef unsigned long hash_value_t
 
using minstd_rand0 = linear_congruential_engine< uint_fast32_t, 16807, 0, 2147483647 >
 
using minstd_rand = linear_congruential_engine< uint_fast32_t, 48271, 0, 2147483647 >
 
using mt19937 = mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253 >
 
using mt19937_64 = mersenne_twister_engine< uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9, 29, 0x5555555555555555, 17, 0x71d67fffeda60000, 37, 0xfff7eee000000000, 43, 6364136223846793005 >
 
using ranlux24_base = subtract_with_carry_engine< uint_fast32_t, 24, 10, 24 >
 
using ranlux48_base = subtract_with_carry_engine< uint_fast64_t, 48, 5, 12 >
 
using ranlux24 = discard_block_engine< ranlux24_base, 223, 23 >
 
using ranlux48 = discard_block_engine< ranlux48_base, 389, 11 >
 
using knuth_b = shuffle_order_engine< minstd_rand0, 256 >
 
using isaac32 = isaac_engine< uint32_t, 32, 0x9e3779b9 >
 
using isaac64 = isaac_engine< uint64_t, 64, 0x9e3779b97f4a7c13 >
 
using default_random_engine = ASSTL_RND_DEFAULT
 
typedef void(* new_handler) ()
 
typedef basic_stringstream< char > stringstream
 
typedef enum std::SeekOrigin seek_t
 
using string = basic_string< char >
 
typedef pthread_t native_thread_handle
 
template<class ... ts>
using void_t = typename make_void< ts ... >::type
 
typedef integral_constant< bool, true > true_type
 
typedef integral_constant< bool, false > false_type
 

Aufzählungen

enum  e_noinitialize { e_noinitialize::noinitialize }
 
enum  filemode { filemode::read, filemode::write, filemode::rw }
 
enum  SeekOrigin { SeekOrigin::Beginn = 0, SeekOrigin::End = 2, SeekOrigin::Current = 1 }
 
enum  flags_t {
  flags_t::boolalpha = 0x0001, flags_t::showbase = 0x0002, flags_t::showpoint = 0x0004, flags_t::showpos = 0x0008,
  flags_t::skipws = 0x0010, flags_t::unitbuf = 0x0020, flags_t::uppercase = 0x0040, flags_t::dec = 0x0080,
  flags_t::hex = 0x0100, flags_t::oct = 0x0200, flags_t::bin = 0x0400, flags_t::internal = 0x0800,
  flags_t::hexbase = 0x0100 | 0x0002
}
 

Funktionen

template<typename T >
void copy_construct (T *mem, const T &orig)
 
template<typename T >
void construct (T *mem)
 
template<typename T >
void destruct (T *mem)
 
template<typename T >
void copy_n (const T *first, size_t n, T *result)
 
template<typename T >
void copy (const T *first, const T *last, T *result)
 
template<typename T >
void copy_construct_n (T *first, size_t n, T *result)
 
template<typename T >
void move_n (const T *from, size_t n, T *result)
 
template<typename T >
void move (const T *first, const T *last, T *result)
 
template<class TIter , class TFn >
TFn for_each (TIter first, TIter last, TFn fn)
 
template<typename T >
void construct_n (T *first, size_t n)
 
template<typename T >
void destruct_n (T *first, size_t n)
 
template<typename T >
void fill_n (T *first, size_t n, const T &val)
 
template<typename TIter , typename TDist >
void distance (TIter first, TIter last, TDist &dist)
 
template<typename TIter , typename TDist >
void advance (TIter &iter, TDist off)
 
template<class TIter , typename T , class TPred >
TIter lower_bound (TIter first, TIter last, const T &val, const TPred &pred)
 
template<class TIter , typename T , class TPred >
TIter upper_bound (TIter first, TIter last, const T &val, const TPred &pred)
 
template<class TIter , typename T >
TIter find (TIter first, TIter last, const T &val)
 
template<class TIter , typename T , class TPred >
TIter find_if (TIter first, TIter last, const T &val, const TPred &pred)
 
template<class TIter , typename T >
void accumulate (TIter first, TIter last, T &result)
 
template<typename T >
T abs (const T &t)
 
int abs (int x)
 
short abs (short x)
 
template<typename T >
T _max (const T &x, const T &y)
 
template<typename T >
T _min (const T &x, const T &y)
 
template<typename TAssignable >
void swap (TAssignable &a, TAssignable &b)
 
bool operator== (const allocator &lhs, const allocator &rhs)
 
bool operator!= (const allocator &lhs, const allocator &rhs)
 
template<typename T , size_t N>
bool operator== (const array< T, N > &a, const array< T, N > &b)
 
template<typename T , size_t N>
bool operator<= (const array< T, N > &a, const array< T, N > &b)
 
template<typename T , size_t N>
bool operator>= (const array< T, N > &a, const array< T, N > &b)
 
template<typename T , size_t N>
bool operator< (const array< T, N > &a, const array< T, N > &b)
 
template<typename T , size_t N>
bool operator> (const array< T, N > &a, const array< T, N > &b)
 
template<typename E , class TStorage , class TAllocator >
bool operator== (const basic_string< E, TStorage, TAllocator > &lhs, const basic_string< E, TStorage, TAllocator > &rhs)
 
template<typename E , class TStorage , class TAllocator >
bool operator!= (const basic_string< E, TStorage, TAllocator > &lhs, const basic_string< E, TStorage, TAllocator > &rhs)
 
template<typename E , class TStorage , class TAllocator >
bool operator< (const basic_string< E, TStorage, TAllocator > &lhs, const basic_string< E, TStorage, TAllocator > &rhs)
 
template<typename E , class TStorage , class TAllocator >
bool operator> (const basic_string< E, TStorage, TAllocator > &lhs, const basic_string< E, TStorage, TAllocator > &rhs)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator+ (const vector< T, TAllocator, TStorage > &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator+ (const vector< T, TAllocator, TStorage > &a, const T &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator+ (const T &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator- (const vector< T, TAllocator, TStorage > &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator- (const vector< T, TAllocator, TStorage > &a)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator- (const vector< T, TAllocator, TStorage > &a, const T &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator- (const T &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator* (const vector< T, TAllocator, TStorage > &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator* (const vector< T, TAllocator, TStorage > &a, const T &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator* (const T &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator/ (const vector< T, TAllocator, TStorage > &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator/ (const vector< T, TAllocator, TStorage > &a, const T &b)
 
template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > operator/ (const T &a, const vector< T, TAllocator, TStorage > &b)
 
template<typename T , class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector< T, TAllocator, TStorage > scale (const vector< T, TAllocator, TStorage > &v, const T s)
 
template<typename T >
T nexthigher (T k)
 
template<class UIntType , UIntType a, UIntType c, UIntType m>
bool operator== (const linear_congruential_engine< UIntType, a, c, m > &lhs, const linear_congruential_engine< UIntType, a, c, m > &rhs)
 
template<class UIntType , UIntType a, UIntType c, UIntType m>
bool operator!= (const linear_congruential_engine< UIntType, a, c, m > &lhs, const linear_congruential_engine< UIntType, a, c, m > &rhs)
 
template<class T = std::lock_base>
void lock (T *m1)
 
template<class T = std::lock_base>
void unlock (T *m1)
 
template<class T = std::lock_base>
void try_lock (T *m1)
 
template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > mat4_string (const std::math::matrix4x4< T > &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > mat4_string (const std::math::mat4f &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > mat4_string (const std::math::mat4d &v, flags_t f=flags_t::dec)
 
template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec2_string (const std::math::vector2< T > &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec2_string (const std::math::vec2f &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec2_string (const std::math::vec2d &v, flags_t f=flags_t::dec)
 
template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec3_string (const std::math::vector3< T > &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec3_string (const std::math::vec3f &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec3_string (const std::math::vec3d &v, flags_t f=flags_t::dec)
 
template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec4_string (const std::math::vector4< T > &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec4_string (const std::math::vec4f &v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > vec4_string (const std::math::vec4d &v, flags_t f=flags_t::dec)
 
new_handler set_new_handler (new_handler new_p)
 
new_handler get_new_handler ()
 
template<typename T1 , typename T2 >
pair< T1, T2 > make_pair (const T1 &a, const T2 &b)
 
bool operator== (const pallocator &lhs, const pallocator &rhs)
 
bool operator!= (const pallocator &lhs, const pallocator &rhs)
 
template<class T >
void swap (scoped_ptr< T > &a, scoped_ptr< T > &b)
 
template<typename T , class TPredicate >
void insertion_sort (T *begin, T *end, TPredicate pred)
 
template<typename T >
void insertion_sort (T *begin, T *end)
 
template<typename T , class TPredicate >
void quick_sort (T *begin, T *end, TPredicate pred)
 
template<typename T >
void quick_sort (T *begin, T *end)
 
template<typename T , class TPredicate >
void heap_sort (T *begin, T *end, TPredicate pred)
 
template<typename T >
void heap_sort (T *begin, T *end)
 
template<typename TIter , typename TPredicate >
bool is_sorted (TIter begin, TIter end, TPredicate pred)
 
std::vector< std::string > split (std::string &strString, const char *delimiter)
 
template<typename T , class StringT >
void tokenize (T *s, T delim, std::vector< StringT > &container)
 
string asstlVersion ()
 
bool operator& (flags_t a, flags_t b)
 
template<typename E , class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
size_t frmstring (basic_string< E, TAllocator, TStorage > &dest, const char *format, va_list arg)
 
template<typename E , class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
basic_string< E, TAllocator, TStorage > frmstring (const char *format,...)
 
template<class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<char, TAllocator>>
basic_string< char > frmstring (const char *format,...)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > to_string (const int32_t v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > to_string (const int64_t v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > to_string (const uint32_t v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string< E, TAllocator, TStorage > to_string (const uint64_t v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator , typename TStorage >
std::basic_string< E, TAllocator, TStorage > to_string (const float v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator , typename TStorage >
std::basic_string< E, TAllocator, TStorage > to_string (const double v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator , typename TStorage >
std::basic_string< E, TAllocator, TStorage > to_string (const bool v, flags_t f=flags_t::dec)
 
template<typename E = char, class TAllocator , typename TStorage >
std::basic_string< E, TAllocator, TStorage > to_string (const void *v, flags_t f=flags_t::dec)
 
 STL_INTEGRAL (char)
 
 STL_INTEGRAL (unsigned char)
 
 STL_INTEGRAL (short)
 
 STL_INTEGRAL (int)
 
 STL_INTEGRAL (long)
 
 STL_INTEGRAL (wchar_t)
 
 STL_INTEGRAL (bool)
 
 STL_RATIONAL (float)
 
 STL_RATIONAL (double)
 
 STL_RATIONAL (long double)
 
 STL_VOIDTYPE (void)
 
 STL_VOIDTYPE (const volatile void)
 
template<class TA , class TB >
bool operator< (const weak_ptr< TA > &a, weak_ptr< TB > const &b)
 
template<class T >
void swap (weak_ptr< T > &a, weak_ptr< T > &b)
 
const char * filemodetostring (filemode_t m, bool a)
 

Variablen

outstream _stdout
 
instream _stdin
 
ofstream __cout (_stdout)
 
ifstream __cin (_stdin)
 

Dokumentation der benutzerdefinierten Typen

◆ adl32_t

using std::adl32_t = typedef adler32<65521>

◆ brnst_t

using std::brnst_t = typedef bernstein<0>

◆ crc32_k

using std::crc32_k = typedef crc32<0x741B8CD7>

◆ crc32_q

using std::crc32_q = typedef crc32<0x814141AB>

◆ crc32_t

using std::crc32_t = typedef crc32<0x04c11db7>

◆ default_hasher

using std::default_hasher = typedef ASSTL_HASH_DEFAULT

◆ default_random_engine

using std::default_random_engine = typedef ASSTL_RND_DEFAULT

◆ ERR_InvalidStringRepSize

typedef char std::ERR_InvalidStringRepSize[sizeof(string_rep)==6 ? 1 :-1]

◆ false_type

typedef integral_constant<bool, false> std::false_type

◆ filemode_t

typedef enum std::filemode std::filemode_t

◆ fint16_t

using std::fint16_t = typedef fast_type<16, int16_t>

◆ fint32_t

using std::fint32_t = typedef fast_type<32, int32_t>

◆ fint64_t

using std::fint64_t = typedef fast_type<64, int64_t>

◆ fint8_t

using std::fint8_t = typedef fast_type<8, int8_t>

◆ fint_least16_t

using std::fint_least16_t = typedef fast_type<16, fint_least16_t>

◆ fint_least32_t

using std::fint_least32_t = typedef fast_type<32, fint_least32_t>

◆ fint_least64_t

using std::fint_least64_t = typedef fast_type<64, fint_least64_t>

◆ fint_least8_t

using std::fint_least8_t = typedef fast_type<8, fint_least8_t>

◆ flt16_t

using std::flt16_t = typedef fletcher16<0>

◆ flt32_t

using std::flt32_t = typedef fletcher32<0>

◆ fnv1a_t

using std::fnv1a_t = typedef fnv1a<2166136261>

◆ fuint16_t

using std::fuint16_t = typedef fast_type<16, uint16_t>

◆ fuint32_t

using std::fuint32_t = typedef fast_type<32, uint32_t>

◆ fuint64_t

using std::fuint64_t = typedef fast_type<64, uint64_t>

◆ fuint8_t

using std::fuint8_t = typedef fast_type<8, uint8_t>

◆ fuint_least16_t

using std::fuint_least16_t = typedef fast_type<16, fuint_least16_t>

◆ fuint_least32_t

using std::fuint_least32_t = typedef fast_type<32, fuint_least32_t>

◆ fuint_least64_t

using std::fuint_least64_t = typedef fast_type<64, fuint_least64_t>

◆ fuint_least8_t

using std::fuint_least8_t = typedef fast_type<8, fuint_least8_t>

◆ hash_value_t

typedef unsigned long std::hash_value_t

◆ isaac32

using std::isaac32 = typedef isaac_engine<uint32_t, 32, 0x9e3779b9>

◆ isaac64

using std::isaac64 = typedef isaac_engine<uint64_t, 64, 0x9e3779b97f4a7c13>

◆ knuth_b

using std::knuth_b = typedef shuffle_order_engine <minstd_rand0,256>

◆ minstd_rand

using std::minstd_rand = typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>

◆ minstd_rand0

using std::minstd_rand0 = typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>

◆ mt19937

using std::mt19937 = typedef mersenne_twister_engine<uint_fast32_t, 32,624,397,31,0x9908b0df, 11,0xffffffff, 7,0x9d2c5680, 15,0xefc60000, 18,1812433253>

◆ mt19937_64

using std::mt19937_64 = typedef mersenne_twister_engine<uint_fast64_t, 64,312,156,31,0xb5026f5aa96619e9, 29,0x5555555555555555, 17,0x71d67fffeda60000, 37,0xfff7eee000000000, 43,6364136223846793005>

◆ native_thread_handle

typedef pthread_t std::native_thread_handle

◆ new_handler

typedef void(* std::new_handler) ()

◆ ranlux24

using std::ranlux24 = typedef discard_block_engine <ranlux24_base, 223, 23>

◆ ranlux24_base

using std::ranlux24_base = typedef subtract_with_carry_engine <uint_fast32_t, 24, 10, 24>

◆ ranlux48

using std::ranlux48 = typedef discard_block_engine <ranlux48_base, 389, 11>

◆ ranlux48_base

using std::ranlux48_base = typedef subtract_with_carry_engine <uint_fast64_t, 48, 5, 12>

◆ seek_t

typedef enum std::SeekOrigin std::seek_t

◆ string

using std::string = typedef basic_string<char>

◆ stringstream

typedef basic_stringstream<char> std::stringstream

◆ true_type

typedef integral_constant<bool, true> std::true_type

◆ void_t

template<class ... ts>
using std::void_t = typedef typename make_void<ts ...>::type

◆ wberg_t

using std::wberg_t = typedef weinberg<0>

Dokumentation der Aufzählungstypen

◆ e_noinitialize

enum std::e_noinitialize
strong
Aufzählungswerte
noinitialize 
124  {
125  noinitialize
126  };

◆ filemode

enum std::filemode
strong
Aufzählungswerte
read 
write 
rw 
42  {
43  read,
44  write,
45  rw,
46  } filemode_t;
std::filemode_t
enum std::filemode filemode_t

◆ flags_t

enum std::flags_t
strong
Aufzählungswerte
boolalpha 
showbase 
showpoint 
showpos 
skipws 
unitbuf 
uppercase 
dec 
hex 
oct 
bin 
internal 
hexbase 
48  {
49  boolalpha = 0x0001,
50  showbase = 0x0002,
51  showpoint = 0x0004,
52  showpos = 0x0008,
53  skipws = 0x0010,
54  unitbuf = 0x0020,
55  uppercase = 0x0040,
56  dec = 0x0080,
57  hex = 0x0100,
58  oct = 0x0200,
59  bin = 0x0400,
60  internal = 0x0800,
61  hexbase = 0x0100 | 0x0002
62  };

◆ SeekOrigin

enum std::SeekOrigin
strong
Aufzählungswerte
Beginn 
End 
Current 
40  {
41  Beginn = 0,
42  End = 2,
43  Current = 1,
44  }seek_t;
std::seek_t
enum std::SeekOrigin seek_t

Dokumentation der Funktionen

◆ _max()

template<typename T >
T std::_max ( const T &  x,
const T &  y 
)
inline
198  {
199  return x > y ? x : y;
200  }

◆ _min()

template<typename T >
T std::_min ( const T &  x,
const T &  y 
)
inline
202  {
203  return x < y ? x : y;
204  }

◆ abs() [1/3]

template<typename T >
T std::abs ( const T &  t)
183  {
184  return t >= T(0) ? t : -t;
185  }

◆ abs() [2/3]

int std::abs ( int  x)
inline
187  {
188  const int y = x >> 31;
189  return (x ^ y) - y;
190  }

◆ abs() [3/3]

short std::abs ( short  x)
inline
192  {
193  const short y = x >> 15;
194  return (x ^ y) - y;
195  }

◆ accumulate()

template<class TIter , typename T >
void std::accumulate ( TIter  first,
TIter  last,
T &  result 
)
174  {
175  while (first != last)
176  {
177  result += *first;
178  ++first;
179  }
180  }

◆ advance()

template<typename TIter , typename TDist >
void std::advance ( TIter &  iter,
TDist  off 
)
inline
116  {
117  internal::advance(iter, off, typename iterator_traits<TIter>::iterator_category());
118  }
std::advance
void advance(TIter &iter, TDist off)
Definition: algorithm.hpp:115

◆ asstlVersion()

string std::asstlVersion ( )
31  {
32  return ASSTL_LIB_NAME;
33  }
ASSTL_LIB_NAME
#define ASSTL_LIB_NAME
Definition: config.h:75

◆ construct()

template<typename T >
void std::construct ( T *  mem)
inline
28  {
29  internal::construct(mem, int_to_type<has_trivial_constructor<T>::value>());
30  }
std::construct
void construct(T *mem)
Definition: algorithm.hpp:27

◆ construct_n()

template<typename T >
void std::construct_n ( T *  first,
size_t  n 
)
85  {
86  internal::construct_n(first, n, int_to_type<has_trivial_constructor<T>::value>());
87  }
std::construct_n
void construct_n(T *first, size_t n)
Definition: algorithm.hpp:84

◆ copy()

template<typename T >
void std::copy ( const T *  first,
const T *  last,
T *  result 
)
40  {
41  internal::copy(first, last, result, int_to_type<has_trivial_copy<T>::value>());
42  }
std::copy
void copy(const T *first, const T *last, T *result)
Definition: algorithm.hpp:39

◆ copy_construct()

template<typename T >
void std::copy_construct ( T *  mem,
const T &  orig 
)
inline
24  {
25  internal::copy_construct(mem, orig, int_to_type<has_trivial_copy<T>::value>());
26  }
std::copy_construct
void copy_construct(T *mem, const T &orig)
Definition: algorithm.hpp:23

◆ copy_construct_n()

template<typename T >
void std::copy_construct_n ( T *  first,
size_t  n,
T *  result 
)
44  {
45  internal::copy_construct_n(first, n, result, int_to_type<has_trivial_copy<T>::value>());
46  }
std::copy_construct_n
void copy_construct_n(T *first, size_t n, T *result)
Definition: algorithm.hpp:43

◆ copy_n()

template<typename T >
void std::copy_n ( const T *  first,
size_t  n,
T *  result 
)
36  {
37  internal::copy_n(first, n, result, int_to_type<has_trivial_copy<T>::value>());
38  }
std::copy_n
void copy_n(const T *first, size_t n, T *result)
Definition: algorithm.hpp:35

◆ destruct()

template<typename T >
void std::destruct ( T *  mem)
inline
32  {
33  internal::destruct(mem, int_to_type<has_trivial_destructor<T>::value>());
34  }
std::destruct
void destruct(T *mem)
Definition: algorithm.hpp:31

◆ destruct_n()

template<typename T >
void std::destruct_n ( T *  first,
size_t  n 
)
89  {
90  internal::destruct_n(first, n, int_to_type<has_trivial_destructor<T>::value>());
91  }
std::destruct_n
void destruct_n(T *first, size_t n)
Definition: algorithm.hpp:88

◆ distance()

template<typename TIter , typename TDist >
void std::distance ( TIter  first,
TIter  last,
TDist &  dist 
)
inline
112  {
113  internal::distance(first, last, dist, typename iterator_traits<TIter>::iterator_category());
114  }
std::distance
void distance(TIter first, TIter last, TDist &dist)
Definition: algorithm.hpp:111

◆ filemodetostring()

const char* std::filemodetostring ( filemode_t  m,
bool  a 
)
inline
33  {
34  std::string s;
35  if(m == filemode::rw) s << "rw";
36  else if(m == filemode::read) s << "r";
37  else if(m == filemode::write) s << "w";
38  s <<( a ? "+b" : "+");
39 
40  return (s).c_str();
41  }
std::basic_string::c_str
const value_type * c_str() const
Definition: basic_string.hpp:199
std::basic_string< char >

◆ fill_n()

template<typename T >
void std::fill_n ( T *  first,
size_t  n,
const T &  val 
)
inline
93  {
94  T* last = first + n;
95  switch (n & 0x7)
96  {
97  case 0:
98  while (first != last)
99  {
100  *first = val; ++first;
101  case 7: *first = val; ++first;
102  case 6: *first = val; ++first;
103  case 5: *first = val; ++first;
104  case 4: *first = val; ++first;
105  case 3: *first = val; ++first;
106  case 2: *first = val; ++first;
107  case 1: *first = val; ++first;
108  }
109  }
110  }

◆ find()

template<class TIter , typename T >
TIter std::find ( TIter  first,
TIter  last,
const T &  val 
)
154  {
155  while (first != last)
156  {
157  if ((*first) == val)
158  return first;
159  ++first;
160  }
161  return last;
162  }

◆ find_if()

template<class TIter , typename T , class TPred >
TIter std::find_if ( TIter  first,
TIter  last,
const T &  val,
const TPred &  pred 
)
164  {
165  while (first != last)
166  {
167  if (pred(*first, val))
168  return first;
169  ++first;
170  }
171  return last;
172  }

◆ for_each()

template<class TIter , class TFn >
TFn std::for_each ( TIter  first,
TIter  last,
TFn  fn 
)
75  {
76  while (first!=last)
77  {
78  fn (*first);
79  ++first;
80  }
81  return (fn);
82  }

◆ frmstring() [1/3]

template<typename E , class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
size_t std::frmstring ( basic_string< E, TAllocator, TStorage > &  dest,
const char *  format,
va_list  arg 
)
inline
101  {
102  size_t length;
103  va_list apStrLen;
104  va_copy(apStrLen, arg);
105  length = Sys::vsnPrintf(NULL, 0, format, apStrLen);
106  va_end(apStrLen);
107 
108 
109  if (length > 0) {
110  dest.resize(length);
111  Sys::vsnPrintf(dest.data(), dest.length(), format, arg);
112  }
113 
114  return length;
115  }

◆ frmstring() [2/3]

template<typename E , class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
basic_string<E, TAllocator, TStorage> std::frmstring ( const char *  format,
  ... 
)
inline
118  {
119  va_list ap;
120  va_start(ap, format);
121  basic_string<E, TAllocator, TStorage> dest;
122  frmstring<E, TAllocator, TStorage>(dest, format, ap);
123  va_end(ap);
124  return dest;
125  }

◆ frmstring() [3/3]

template<class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<char, TAllocator>>
basic_string<char> std::frmstring ( const char *  format,
  ... 
)
inline
128  {
129  va_list ap;
130  va_start(ap, format);
131  basic_string<char, TAllocator, TStorage> dest;
132  frmstring<char, TAllocator, TStorage>(dest, format, ap);
133  va_end(ap);
134  return dest;
135  }

◆ get_new_handler()

new_handler std::get_new_handler ( )
93 {
94  return handler;
95 }
handler
std::new_handler handler
Definition: new.cpp:27

◆ heap_sort() [1/2]

template<typename T , class TPredicate >
void std::heap_sort ( T *  begin,
T *  end,
TPredicate  pred 
)
132  {
133  size_t n = end - begin;
134  for (size_t k = n / 2; k != 0; --k)
135  internal::down_heap(begin, k, n, pred);
136 
137  while (n >= 1)
138  {
139  const T temp = begin[0];
140  begin[0] = begin[n - 1];
141  begin[n - 1] = temp;
142 
143  --n;
144  internal::down_heap(begin, 1, n, pred);
145  }
146  }
std::internal::down_heap
void down_heap(T *data, size_t k, size_t n, TPredicate pred)
Definition: sort.hpp:81

◆ heap_sort() [2/2]

template<typename T >
void std::heap_sort ( T *  begin,
T *  end 
)
148  {
149  heap_sort(begin, end, std::less<T>());
150  }
std::less
Definition: functional.hpp:37
std::heap_sort
void heap_sort(T *begin, T *end)
Definition: sort.hpp:147

◆ insertion_sort() [1/2]

template<typename T , class TPredicate >
void std::insertion_sort ( T *  begin,
T *  end,
TPredicate  pred 
)
102  {
103  const size_t num = end - begin;
104  for (size_t i = 0; i < num; ++i)
105  {
106  const T t = begin[i];
107  size_t j = i;
108  while (j > 0 && pred(t, begin[j - 1]))
109  {
110  begin[j] = begin[j - 1];
111  --j;
112  }
113  begin[j] = t;
114  }
115  }

◆ insertion_sort() [2/2]

template<typename T >
void std::insertion_sort ( T *  begin,
T *  end 
)
117  {
118  insertion_sort(begin, end, less<T>());
119  }
std::insertion_sort
void insertion_sort(T *begin, T *end)
Definition: sort.hpp:116

◆ is_sorted()

template<typename TIter , typename TPredicate >
bool std::is_sorted ( TIter  begin,
TIter  end,
TPredicate  pred 
)
152  {
153  TIter it = begin;
154  TIter it_prev = it;
155  bool is_sorted = true;
156  while (it != end)
157  {
158  if (it_prev != it)
159  {
160  if (pred(*it, *it_prev))
161  {
162  is_sorted = false;
163  break;
164  }
165  }
166  it_prev = it;
167  ++it;
168  }
169  return is_sorted;
170  }
std::is_sorted
bool is_sorted(TIter begin, TIter end, TPredicate pred)
Definition: sort.hpp:151

◆ lock()

template<class T = std::lock_base>
void std::lock ( T *  m1)
58 { m1->lock(); }

◆ lower_bound()

template<class TIter , typename T , class TPred >
TIter std::lower_bound ( TIter  first,
TIter  last,
const T &  val,
const TPred &  pred 
)
inline
120  {
121  internal::test_ordering(first, last, pred);
122  int dist(0);
123  distance(first, last, dist);
124  while (dist > 0)
125  {
126  const int halfDist = dist >> 1;
127  TIter mid = first;
128  advance(mid, halfDist);
129  if (internal::debug_pred(pred, *mid, val))
130  first = ++mid, dist -= halfDist + 1;
131  else
132  dist = halfDist;
133  }
134  return first;
135  }
std::distance
void distance(TIter first, TIter last, TDist &dist)
Definition: algorithm.hpp:111
std::internal::debug_pred
bool debug_pred(const TPred &pred, const T1 &a, const T2 &b)
Definition: utility.hpp:183
std::advance
void advance(TIter &iter, TDist off)
Definition: algorithm.hpp:115
std::internal::test_ordering
void test_ordering(TIter first, TIter last, const TPred &pred)
Definition: utility.hpp:178

◆ make_pair()

template<typename T1 , typename T2 >
pair<T1, T2> std::make_pair ( const T1 &  a,
const T2 &  b 
)
77  {
78  return pair<T1, T2>(a, b);
79  }

◆ mat4_string() [1/3]

template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::mat4_string ( const std::math::matrix4x4< T > &  v,
flags_t  f = flags_t::dec 
)
inline
563  {
564  return v.to_string<E, TAllocator, TStorage>(); }
std::math::matrix4x4::to_string
std::basic_string< E, TAllocator, TStorage > to_string()
Definition: matrix4x4.hpp:155

◆ mat4_string() [2/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::mat4_string ( const std::math::mat4f &  v,
flags_t  f = flags_t::dec 
)
inline
568  {
569  return std::mat4_string<float, E, TAllocator, TStorage>(v); }

◆ mat4_string() [3/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::mat4_string ( const std::math::mat4d &  v,
flags_t  f = flags_t::dec 
)
inline
572  {
573  return std::mat4_string<double, E, TAllocator, TStorage>(v); }

◆ move()

template<typename T >
void std::move ( const T *  first,
const T *  last,
T *  result 
)
inline
61  {
62  assert(first != result || first == last);
63  const size_t n = reinterpret_cast<uintptr_t>(last) - reinterpret_cast<uintptr_t>(first);
64  const unsigned char* resultEnd = reinterpret_cast<const unsigned char*>(result) + n;
65  if (resultEnd >= reinterpret_cast<const unsigned char*>(first) && result < last)
66  {
67  internal::move(first, last, result, int_to_type<has_trivial_copy<T>::value>());
68  }
69  else
70  {
71  internal::copy(first, last, result, int_to_type<has_trivial_copy<T>::value>());
72  }
73  }
std::move
void move(const T *first, const T *last, T *result)
Definition: algorithm.hpp:60
std::copy
void copy(const T *first, const T *last, T *result)
Definition: algorithm.hpp:39

◆ move_n()

template<typename T >
void std::move_n ( const T *  from,
size_t  n,
T *  result 
)
48  {
49  assert(from != result || n == 0);
50 
51  if (result + n >= from && result < from + n)
52  {
53  internal::move_n(from, n, result, int_to_type<has_trivial_copy<T>::value>());
54  }
55  else
56  {
57  internal::copy_n(from, n, result, int_to_type<has_trivial_copy<T>::value>());
58  }
59  }
std::copy_n
void copy_n(const T *first, size_t n, T *result)
Definition: algorithm.hpp:35
std::move_n
void move_n(const T *from, size_t n, T *result)
Definition: algorithm.hpp:47

◆ nexthigher()

template<typename T >
T std::nexthigher ( T  k)
59  {
60  k--;
61  for (unsigned int i=1; i< sizeof(T) * 8; i <<= 1)
62  k |= (k >> i);
63  return k+1;
64  }

◆ operator!=() [1/4]

bool std::operator!= ( const pallocator &  lhs,
const pallocator &  rhs 
)
inline
61  {
62  return !(lhs == rhs);
63  }

◆ operator!=() [2/4]

bool std::operator!= ( const allocator &  lhs,
const allocator &  rhs 
)
inline
67  {
68  return !(lhs == rhs);
69  }

◆ operator!=() [3/4]

template<class UIntType , UIntType a, UIntType c, UIntType m>
bool std::operator!= ( const linear_congruential_engine< UIntType, a, c, m > &  lhs,
const linear_congruential_engine< UIntType, a, c, m > &  rhs 
)
78  {
79  return !(lhs == rhs);
80  }

◆ operator!=() [4/4]

template<typename E , class TStorage , class TAllocator >
bool std::operator!= ( const basic_string< E, TStorage, TAllocator > &  lhs,
const basic_string< E, TStorage, TAllocator > &  rhs 
)
366  {
367  return !(lhs == rhs);
368  }

◆ operator&()

bool std::operator & ( flags_t  a,
flags_t  b 
)
inline
63  {
64  return ((int)a) & ((int)b);
65  }

◆ operator*() [1/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator* ( const vector< T, TAllocator, TStorage > &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
127  {
128  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
129  int size = (calc != 0 ? calc : a.size());
130 #ifdef ASSTL_USE_OPENMP
131  #pragma omp parallel for
132 #endif
133  for(int i = 0; i < size; i++)
134  c.push_back(a[i] * b[i]);
135  return c;
136  }

◆ operator*() [2/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator* ( const vector< T, TAllocator, TStorage > &  a,
const T &  b 
)
inline
139  {
140  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
141  int size = (calc != 0 ? calc : a.size());
142 #ifdef ASSTL_USE_OPENMP
143  #pragma omp parallel for
144 #endif
145  for(int i = 0; i < size; i++)
146  c.push_back(a[i] * b);
147  return c;
148  }

◆ operator*() [3/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator* ( const T &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
151  {
152  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
153  int size = (calc != 0 ? calc : b.size());
154 #ifdef ASSTL_USE_OPENMP
155  #pragma omp parallel for
156 #endif
157  for(int i = 0; i < size; i++)
158  c.push_back(a * b[i]);
159  return c;
160  }

◆ operator+() [1/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator+ ( const vector< T, TAllocator, TStorage > &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
42  {
43  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
44  int size = (calc != 0 ? calc : a.size());
45 #ifdef ASSTL_USE_OPENMP
46  #pragma omp parallel for
47 #endif
48  for(int i = 0; i < size; i++)
49  c.push_back(a[i] + b[i]);
50  return c;
51  }

◆ operator+() [2/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator+ ( const vector< T, TAllocator, TStorage > &  a,
const T &  b 
)
inline
54  {
55  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
56  int size = (calc != 0 ? calc : a.size());
57 #ifdef ASSTL_USE_OPENMP
58  #pragma omp parallel for
59 #endif
60  for(int i = 0; i < size; i++)
61  c.push_back(a[i] + b);
62  return c;
63  }

◆ operator+() [3/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator+ ( const T &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
66  {
67  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
68  int size = (calc != 0 ? calc : b.size());
69 #ifdef ASSTL_USE_OPENMP
70  #pragma omp parallel for
71 #endif
72  for(int i = 0; i < size; i++)
73  c.push_back(a + b[i]);
74  return c;
75  }

◆ operator-() [1/4]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator- ( const vector< T, TAllocator, TStorage > &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
79  {
80  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
81  int size = (calc != 0 ? calc : a.size());
82 #ifdef ASSTL_USE_OPENMP
83  #pragma omp parallel for
84 #endif
85  for(int i = 0; i < size; i++)
86  c.push_back(a[i] - b[i]);
87  return c;
88  }

◆ operator-() [2/4]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator- ( const vector< T, TAllocator, TStorage > &  a)
inline
90  {
91  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
92  int size = (calc != 0 ? calc : a.size());
93 #ifdef ASSTL_USE_OPENMP
94  #pragma omp parallel for
95 #endif
96  for(int i = 0; i < size; i++)
97  c.push_back(-a[i]);
98  return c;
99  }

◆ operator-() [3/4]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator- ( const vector< T, TAllocator, TStorage > &  a,
const T &  b 
)
inline
102  {
103  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
104  int size = (calc != 0 ? calc : a.size());
105 #ifdef ASSTL_USE_OPENMP
106  #pragma omp parallel for
107 #endif
108  for(int i = 0; i < size; i++)
109  c.push_back(a[i] - b);
110  return c;
111  }

◆ operator-() [4/4]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator- ( const T &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
114  {
115  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
116  int size = (calc != 0 ? calc : b.size());
117 #ifdef ASSTL_USE_OPENMP
118  #pragma omp parallel for
119 #endif
120  for(int i = 0; i < size; i++)
121  c.push_back(a - b[i]);
122  return c;
123  }

◆ operator/() [1/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator/ ( const vector< T, TAllocator, TStorage > &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
164  {
165  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
166  int size = (calc != 0 ? calc : a.size());
167 #ifdef ASSTL_USE_OPENMP
168  #pragma omp parallel for
169 #endif
170  for(int i = 0; i < size; i++)
171  c.push_back(a[i] / b[i]);
172  return c;
173  }

◆ operator/() [2/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator/ ( const vector< T, TAllocator, TStorage > &  a,
const T &  b 
)
inline
176  {
177  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
178  int size = (calc != 0 ? calc : a.size());
179 #ifdef ASSTL_USE_OPENMP
180  #pragma omp parallel for
181 #endif
182  for(int i = 0; i < size; i++)
183  c.push_back(a[i] / b);
184  return c;
185  }

◆ operator/() [3/3]

template<typename T , int calc = 0, class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::operator/ ( const T &  a,
const vector< T, TAllocator, TStorage > &  b 
)
inline
188  {
189  vector<T, TAllocator, TStorage> c = vector<T, TAllocator, TStorage>();
190  int size = (calc != 0 ? calc : b.size());
191 #ifdef ASSTL_USE_OPENMP
192  #pragma omp parallel for
193 #endif
194  for(int i = 0; i < size; i++)
195  c.push_back(a / b[i]);
196  return c;
197  }

◆ operator<() [1/3]

template<class TA , class TB >
bool std::operator< ( const weak_ptr< TA > &  a,
weak_ptr< TB > const &  b 
)
inline
115  {
116  return a.owner_before( b );
117  }

◆ operator<() [2/3]

template<typename T , size_t N>
bool std::operator< ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
127  {
128  size_t size = std::_min<size_t>(a.size(), b.size());
129  for (int i =0; i < size; i++)
130  if(a[i] > b[i])
131  return false;
132  return true;
133  }

◆ operator<() [3/3]

template<typename E , class TStorage , class TAllocator >
bool std::operator< ( const basic_string< E, TStorage, TAllocator > &  lhs,
const basic_string< E, TStorage, TAllocator > &  rhs 
)
372  {
373  return lhs.compare(rhs) < 0;
374  }

◆ operator<=()

template<typename T , size_t N>
bool std::operator<= ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
111  {
112  size_t size = std::_min<size_t>(a.size(), b.size());
113  for (int i =0; i < size; i++)
114  if(a[i] >= b[i])
115  return false;
116  return true;
117  }

◆ operator==() [1/5]

bool std::operator== ( const pallocator &  lhs,
const pallocator &  rhs 
)
inline
58  {
59  return !strcmp(lhs.get_name(), rhs.get_name());
60  }

◆ operator==() [2/5]

bool std::operator== ( const allocator &  lhs,
const allocator &  rhs 
)
inline
63  {
64  return !strcmp(lhs.get_name(), rhs.get_name());
65  }

◆ operator==() [3/5]

template<class UIntType , UIntType a, UIntType c, UIntType m>
bool std::operator== ( const linear_congruential_engine< UIntType, a, c, m > &  lhs,
const linear_congruential_engine< UIntType, a, c, m > &  rhs 
)
70  {
71  if(lhs.multiplier != rhs.multiplier) return false;
72  if(lhs.increment != rhs.increment) return false;
73  if(lhs.modulus != rhs.modulus) return false;
74  return true;
75  }

◆ operator==() [4/5]

template<typename T , size_t N>
bool std::operator== ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
99  {
100  if(a.size() != b.size()) return false;
101  for (int i =0; i < a.size(); i++)
102  if(a[i] != b[i])
103  return false;
104  return true;
105  }

◆ operator==() [5/5]

template<typename E , class TStorage , class TAllocator >
bool std::operator== ( const basic_string< E, TStorage, TAllocator > &  lhs,
const basic_string< E, TStorage, TAllocator > &  rhs 
)
361  {
362  return lhs.compare(rhs) == 0;
363  }

◆ operator>() [1/2]

template<typename T , size_t N>
bool std::operator> ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
135  {
136  size_t size = std::_min<size_t>(a.size(), b.size());
137  for (int i =0; i < size; i++)
138  if(a[i] < b[i])
139  return false;
140  return true;
141  }

◆ operator>() [2/2]

template<typename E , class TStorage , class TAllocator >
bool std::operator> ( const basic_string< E, TStorage, TAllocator > &  lhs,
const basic_string< E, TStorage, TAllocator > &  rhs 
)
378  {
379  return lhs.compare(rhs) > 0;
380  }

◆ operator>=()

template<typename T , size_t N>
bool std::operator>= ( const array< T, N > &  a,
const array< T, N > &  b 
)
inline
119  {
120  size_t size = std::_min<size_t>(a.size(), b.size());
121  for (int i =0; i < size; i++)
122  if(a[i] <= b[i])
123  return false;
124  return true;
125  }

◆ quick_sort() [1/2]

template<typename T , class TPredicate >
void std::quick_sort ( T *  begin,
T *  end,
TPredicate  pred 
)
122  {
123  if (end - begin > 1)
124  internal::quick_sort(begin, 0, (long)(end - begin - 1), pred);
125  }
std::quick_sort
void quick_sort(T *begin, T *end)
Definition: sort.hpp:126

◆ quick_sort() [2/2]

template<typename T >
void std::quick_sort ( T *  begin,
T *  end 
)
127  {
128  quick_sort(begin, end, less<T>());
129  }
std::quick_sort
void quick_sort(T *begin, T *end)
Definition: sort.hpp:126

◆ scale()

template<typename T , class TAllocator = std::allocator, class TStorage = standard_vector_storage<T, TAllocator>>
vector<T, TAllocator, TStorage> std::scale ( const vector< T, TAllocator, TStorage > &  v,
const T  s 
)
inline
201  {
202  return v * s;
203  }

◆ set_new_handler()

new_handler std::set_new_handler ( new_handler  new_p)
87 {
88  std::new_handler old = handler;
89  handler = new_p;
90  return old;
91 }
std::new_handler
void(* new_handler)()
Definition: new.hpp:52
handler
std::new_handler handler
Definition: new.cpp:27

◆ split()

std::vector< std::string > std::split ( std::string &  strString,
const char *  delimiter 
)
30  {
31  std::vector<std::string> container;
32  tokenize<char, std::string>
33  ((char*)strString.c_str(), delimiter[0], container);
34  return container;
35  }
std::basic_string::c_str
const value_type * c_str() const
Definition: basic_string.hpp:199
std::vector
Definition: vector.hpp:111

◆ STL_INTEGRAL() [1/7]

std::STL_INTEGRAL ( char  )

◆ STL_INTEGRAL() [2/7]

std::STL_INTEGRAL ( unsigned  char)

◆ STL_INTEGRAL() [3/7]

std::STL_INTEGRAL ( short  )

◆ STL_INTEGRAL() [4/7]

std::STL_INTEGRAL ( int  )

◆ STL_INTEGRAL() [5/7]

std::STL_INTEGRAL ( long  )

◆ STL_INTEGRAL() [6/7]

std::STL_INTEGRAL ( wchar_t  )

◆ STL_INTEGRAL() [7/7]

std::STL_INTEGRAL ( bool  )

◆ STL_RATIONAL() [1/3]

std::STL_RATIONAL ( float  )

◆ STL_RATIONAL() [2/3]

std::STL_RATIONAL ( double  )

◆ STL_RATIONAL() [3/3]

std::STL_RATIONAL ( long  double)

◆ STL_VOIDTYPE() [1/2]

std::STL_VOIDTYPE ( void  )

◆ STL_VOIDTYPE() [2/2]

std::STL_VOIDTYPE ( const volatile  void)

◆ swap() [1/3]

template<class T >
void std::swap ( scoped_ptr< T > &  a,
scoped_ptr< T > &  b 
)
inline
78  {
79  a.swap(b);
80  }

◆ swap() [2/3]

template<class T >
void std::swap ( weak_ptr< T > &  a,
weak_ptr< T > &  b 
)
119  {
120  a.swap(b);
121  }

◆ swap() [3/3]

template<typename TAssignable >
void std::swap ( TAssignable &  a,
TAssignable &  b 
)
206  {
207  TAssignable tmp(a);
208  a = b;
209  b = tmp;
210  }

◆ to_string() [1/8]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::to_string ( const int32_t  v,
flags_t  f = flags_t::dec 
)
inline
139  {
140  std::basic_string<E, TAllocator, TStorage> fmt =
141  internal::__flagstostring<E, TAllocator, TStorage >(f);
142  return std::frmstring<E, TAllocator, TStorage>(fmt.c_str(), v); }
std::basic_string::c_str
const value_type * c_str() const
Definition: basic_string.hpp:199
std::basic_string
Definition: basic_string.hpp:45

◆ to_string() [2/8]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::to_string ( const int64_t  v,
flags_t  f = flags_t::dec 
)
inline
145  {
146  std::basic_string<E, TAllocator, TStorage> fmt =
147  internal::__flagstostring<E, TAllocator, TStorage >(f);
148  return std::frmstring<E, TAllocator, TStorage>(fmt.c_str(), v); }
std::basic_string::c_str
const value_type * c_str() const
Definition: basic_string.hpp:199
std::basic_string
Definition: basic_string.hpp:45

◆ to_string() [3/8]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::to_string ( const uint32_t  v,
flags_t  f = flags_t::dec 
)
inline
151  {
152  std::basic_string<E, TAllocator, TStorage> fmt =
153  internal::__flagstostring<E, TAllocator, TStorage >(f);
154  return std::frmstring<E, TAllocator, TStorage>(fmt.c_str(), v); }
std::basic_string::c_str
const value_type * c_str() const
Definition: basic_string.hpp:199
std::basic_string
Definition: basic_string.hpp:45

◆ to_string() [4/8]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::to_string ( const uint64_t  v,
flags_t  f = flags_t::dec 
)
inline
157  {
158  std::basic_string<E, TAllocator, TStorage> fmt =
159  internal::__flagstostring<E, TAllocator, TStorage >(f);
160  return std::frmstring<E, TAllocator, TStorage>(fmt.c_str(), v); }
std::basic_string::c_str
const value_type * c_str() const
Definition: basic_string.hpp:199
std::basic_string
Definition: basic_string.hpp:45

◆ to_string() [5/8]

template<typename E = char, class TAllocator , typename TStorage >
std::basic_string<E, TAllocator, TStorage> std::to_string ( const float  v,
flags_t  f = flags_t::dec 
)
inline
163  {
164  return std::frmstring("%f", v); }
std::frmstring
size_t frmstring(basic_string< E, TAllocator, TStorage > &dest, const char *format, va_list arg)
Definition: string.hpp:99

◆ to_string() [6/8]

template<typename E = char, class TAllocator , typename TStorage >
std::basic_string<E, TAllocator, TStorage> std::to_string ( const double  v,
flags_t  f = flags_t::dec 
)
inline
167  {
168  return std::frmstring("%f", v); }
std::frmstring
size_t frmstring(basic_string< E, TAllocator, TStorage > &dest, const char *format, va_list arg)
Definition: string.hpp:99

◆ to_string() [7/8]

template<typename E = char, class TAllocator , typename TStorage >
std::basic_string<E, TAllocator, TStorage> std::to_string ( const bool  v,
flags_t  f = flags_t::dec 
)
inline
171  {
172  return std::frmstring("%s", (v ? "true" : "false") ); }
std::frmstring
size_t frmstring(basic_string< E, TAllocator, TStorage > &dest, const char *format, va_list arg)
Definition: string.hpp:99

◆ to_string() [8/8]

template<typename E = char, class TAllocator , typename TStorage >
std::basic_string<E, TAllocator, TStorage> std::to_string ( const void *  v,
flags_t  f = flags_t::dec 
)
inline
175  {
176  return std::frmstring("%p", v ); }
std::frmstring
size_t frmstring(basic_string< E, TAllocator, TStorage > &dest, const char *format, va_list arg)
Definition: string.hpp:99

◆ tokenize()

template<typename T , class StringT >
void std::tokenize ( T *  s,
T  delim,
std::vector< StringT > &  container 
)
46  {
47  const T *olds = s;
48  T olddelim = delim;
49 
50  while(olddelim && *s)
51  {
52  while(*s && (delim != *s)) s++;
53  *s ^= olddelim = *s;
54  container.push_back(StringT(olds));
55  *s++ ^= olddelim;
56  olds = s;
57  }
58  }
std::vector::push_back
void push_back(const T &v)
Definition: vector.hpp:262

◆ try_lock()

template<class T = std::lock_base>
void std::try_lock ( T *  m1)
60 { m1->try_lock(); }

◆ unlock()

template<class T = std::lock_base>
void std::unlock ( T *  m1)
59 { m1->unlock(); }

◆ upper_bound()

template<class TIter , typename T , class TPred >
TIter std::upper_bound ( TIter  first,
TIter  last,
const T &  val,
const TPred &  pred 
)
inline
137  {
138  internal::test_ordering(first, last, pred);
139  int dist(0);
140  distance(first, last, dist);
141  while (dist > 0)
142  {
143  const int halfDist = dist >> 1;
144  TIter mid = first;
145  advance(mid, halfDist);
146  if (!internal::debug_pred(pred, val, *mid))
147  first = ++mid, dist -= halfDist + 1;
148  else
149  dist = halfDist;
150  }
151  return first;
152  }
std::distance
void distance(TIter first, TIter last, TDist &dist)
Definition: algorithm.hpp:111
std::internal::debug_pred
bool debug_pred(const TPred &pred, const T1 &a, const T2 &b)
Definition: utility.hpp:183
std::advance
void advance(TIter &iter, TDist off)
Definition: algorithm.hpp:115
std::internal::test_ordering
void test_ordering(TIter first, TIter last, const TPred &pred)
Definition: utility.hpp:178

◆ vec2_string() [1/3]

template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec2_string ( const std::math::vector2< T > &  v,
flags_t  f = flags_t::dec 
)
inline
194  {
195  return v.to_string<E, TAllocator, TStorage>(); }
std::math::vector2::to_string
std::basic_string< E, TAllocator, TStorage > to_string()
Definition: vector2.hpp:98

◆ vec2_string() [2/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec2_string ( const std::math::vec2f &  v,
flags_t  f = flags_t::dec 
)
inline
199  {
200  return std::vec2_string<float, E, TAllocator, TStorage>(v); }

◆ vec2_string() [3/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec2_string ( const std::math::vec2d &  v,
flags_t  f = flags_t::dec 
)
inline
203  {
204  return std::vec2_string<double, E, TAllocator, TStorage>(v); }

◆ vec3_string() [1/3]

template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec3_string ( const std::math::vector3< T > &  v,
flags_t  f = flags_t::dec 
)
inline
190  {
191  return v.to_string<E, TAllocator, TStorage>(); }
std::math::vector3::to_string
std::basic_string< E, TAllocator, TStorage > to_string()
Definition: vector3.hpp:94

◆ vec3_string() [2/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec3_string ( const std::math::vec3f &  v,
flags_t  f = flags_t::dec 
)
inline
195  {
196  return std::vec3_string<float, E, TAllocator, TStorage>(v); }

◆ vec3_string() [3/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec3_string ( const std::math::vec3d &  v,
flags_t  f = flags_t::dec 
)
inline
199  {
200  return std::vec3_string<double, E, TAllocator, TStorage>(v); }

◆ vec4_string() [1/3]

template<typename T , typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec4_string ( const std::math::vector4< T > &  v,
flags_t  f = flags_t::dec 
)
inline
183  {
184  return v.to_string<E, TAllocator, TStorage>(); }
std::math::vector4::to_string
std::basic_string< E, TAllocator, TStorage > to_string()
Definition: vector4.hpp:97

◆ vec4_string() [2/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec4_string ( const std::math::vec4f &  v,
flags_t  f = flags_t::dec 
)
inline
188  {
189  return std::vec4_string<float, E, TAllocator, TStorage>(v); }

◆ vec4_string() [3/3]

template<typename E = char, class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
std::basic_string<E, TAllocator, TStorage> std::vec4_string ( const std::math::vec4d &  v,
flags_t  f = flags_t::dec 
)
inline
192  {
193  return std::vec4_string<double, E, TAllocator, TStorage>(v); }

Variablen-Dokumentation

◆ __cin

ifstream std::__cin(_stdin)

◆ __cout

ofstream std::__cout(_stdout)

◆ _stdin

instream std::_stdin

◆ _stdout

outstream std::_stdout