std::internal-Namensbereichsreferenz

Klassen
struct	_mod< Tp, m, a, c, true, s >
struct	alignof_helper
struct	compare_func
struct	list_base_node
struct	rb_tree_base
struct	rb_tree_key_wrapper
struct	rb_tree_traits
struct	slist_base_node
struct	type_with_alignment
struct	type_with_alignment< 0 >
struct	type_with_alignment< 1 >
struct	type_with_alignment< 16 >
struct	type_with_alignment< 2 >
struct	type_with_alignment< 4 >
struct	type_with_alignment< 8 >

Funktionen
struct	__attribute__ ((aligned(16))) aligned16
template<typename Tp , Tp m, Tp a = 1, Tp c = 0>
Tp	mod (Tp x)
template<typename TIter , typename TDist >
void	distance (TIter first, TIter last, TDist &dist, std::random_access_iterator_tag)
template<typename TIter , typename TDist >
void	distance (TIter first, TIter last, TDist &dist, std::input_iterator_tag)
template<typename TIter , typename TDist >
void	advance (TIter &iter, TDist d, std::random_access_iterator_tag)
template<typename TIter , typename TDist >
void	advance (TIter &iter, TDist d, std::bidirectional_iterator_tag)
template<typename TIter , typename TDist >
void	advance (TIter &iter, TDist d, std::input_iterator_tag)
template<typename T , class TPredicate >
void	quick_sort (T *data, long low, long high, TPredicate pred)
template<typename T , class TPredicate >
void	down_heap (T *data, size_t k, size_t n, TPredicate pred)
template<typename E , class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>
basic_string< E, TAllocator, TStorage >	__flagstostring (std::flags_t f=std::flags_t::dec)
template<class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<char, TAllocator>>
basic_string< char, TAllocator, TStorage >	__flagstostring (std::flags_t f=std::flags_t::dec)
template<typename T >
void	copy_n (const T *first, size_t n, T *result, int_to_type< false >)
template<typename T >
void	copy_n (const T *first, size_t n, T *result, int_to_type< true >)
template<typename T >
void	copy (const T *first, const T *last, T *result, int_to_type< false >)
template<typename T >
void	copy (const T *first, const T *last, T *result, int_to_type< true >)
template<typename T >
void	move_n (const T *from, size_t n, T *result, int_to_type< false >)
template<typename T >
void	move_n (const T *first, size_t n, T *result, int_to_type< true >)
template<typename T >
void	move (const T *first, const T *last, T *result, int_to_type< false >)
template<typename T >
void	move (const T *first, const T *last, T *result, int_to_type< true >)
template<typename T >
void	copy_construct_n (const T *first, size_t n, T *result, int_to_type< false >)
template<typename T >
void	copy_construct_n (const T *first, size_t n, T *result, int_to_type< true >)
template<typename T >
void	destruct_n (T *first, size_t n, int_to_type< false >)
template<typename T >
void	destruct_n (T *, size_t, int_to_type< true >)
template<typename T >
void	destruct (T *mem, int_to_type< false >)
template<typename T >
void	destruct (T *, int_to_type< true >)
template<typename T >
void	construct (T *mem, int_to_type< false >)
template<typename T >
void	construct (T *, int_to_type< true >)
template<typename T >
void	copy_construct (T *mem, const T &orig, int_to_type< false >)
template<typename T >
void	copy_construct (T *mem, const T &orig, int_to_type< true >)
template<typename T >
void	construct_n (T *to, size_t count, int_to_type< false >)
template<typename T >
void	construct_n (T *, int, int_to_type< true >)
template<class TIter , class TPred >
void	test_ordering (TIter first, TIter last, const TPred &pred)
template<typename T1 , typename T2 , class TPred >
bool	debug_pred (const TPred &pred, const T1 &a, const T2 &b)

Dokumentation der Funktionen

__attribute__()

struct std::internal::__attribute__

(

(aligned(16))

)

{ uint64_t member[2]; } ;

__flagstostring() [1/2]

template<typename E , class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<E, TAllocator>>

basic_string<E, TAllocator, TStorage> std::internal::__flagstostring ( std::flags_t  f = std::flags_t::dec )

inline

                                                                                                        {
                if (f & flags_t::dec)
                    return basic_string<E, TAllocator, TStorage>("d");
        else if (f & flags_t::hex && f & flags_t::showbase)
                    return basic_string<E, TAllocator, TStorage>("0x%X");
        else if (f & flags_t::hex)
                    return basic_string<E, TAllocator, TStorage>("%X");
        else if (f & flags_t::oct)
                    {}//itoa(buf, 8, i);
        else if (f & flags_t::bin)
                    return basic_string<E, TAllocator, TStorage>("%b");
        return basic_string<E, TAllocator, TStorage>("%d");
            }

__flagstostring() [2/2]

template<class TAllocator = std::allocator, typename TStorage = std::simple_string_storage<char, TAllocator>>

basic_string<char, TAllocator, TStorage> std::internal::__flagstostring ( std::flags_t  f = std::flags_t::dec )

inline

                                                                                                           {
                return __flagstostring<char, TAllocator, TStorage>(f); 
            }

advance() [1/3]

template<typename TIter , typename TDist >

void std::internal::advance ( TIter &  iter, TDist  d, std::random_access_iterator_tag    )

inline

            {
                    iter += d;
            }

advance() [2/3]

template<typename TIter , typename TDist >

void std::internal::advance ( TIter &  iter, TDist  d, std::bidirectional_iterator_tag    )

inline

            {
                    if (d >= 0)
                    {
                            while (d--)
                                    ++iter;
                    }
                    else
                    {
                            while (d++)
                                    --iter;
                    }
            }

advance() [3/3]

template<typename TIter , typename TDist >

void std::internal::advance ( TIter &  iter, TDist  d, std::input_iterator_tag    )

inline

            {
                    assert(d >= 0);
                    while (d--)
                            ++iter;
            }

construct() [1/2]

template<typename T >

void std::internal::construct	(	T *	mem,
		int_to_type< false >
	)

        {
                new (mem) T();
        }

construct() [2/2]

template<typename T >

void std::internal::construct ( T *  , int_to_type< true >    )

inline

        {
                // Nothing to do
        }

construct_n() [1/2]

template<typename T >

void std::internal::construct_n	(	T *	to,
		size_t	count,
		int_to_type< false >
	)

        {
                sizeof(to);
                for (size_t i = 0; i < count; ++i)
                        new (to + i) T();
        }

construct_n() [2/2]

template<typename T >

void std::internal::construct_n ( T *  , int  , int_to_type< true >    )

inline

        {
                // trivial ctor, nothing to do.
        }

copy() [1/2]

template<typename T >

void std::internal::copy	(	const T *	first,
		const T *	last,
		T *	result,
		int_to_type< false >
	)

        {
                T* localResult = result;
                while (first != last)
                        *localResult++ = *first++;
        }

copy() [2/2]

template<typename T >

void std::internal::copy	(	const T *	first,
		const T *	last,
		T *	result,
		int_to_type< true >
	)

        {
                const size_t n = reinterpret_cast<const char*>(last) - reinterpret_cast<const char*>(first);
                Sys::MemCpy(result, first, n);
        }

copy_construct() [1/2]

template<typename T >

void std::internal::copy_construct ( T *  mem, const T &  orig, int_to_type< false >    )

inline

        {
                new (mem) T(orig);
        }

copy_construct() [2/2]

template<typename T >

void std::internal::copy_construct ( T *  mem, const T &  orig, int_to_type< true >    )

inline

        {
                mem[0] = orig;
        }

copy_construct_n() [1/2]

template<typename T >

void std::internal::copy_construct_n	(	const T *	first,
		size_t	n,
		T *	result,
		int_to_type< false >
	)

        {
                for (size_t i = 0; i < n; ++i)
                        new (result + i) T(first[i]);
        }

copy_construct_n() [2/2]

template<typename T >

void std::internal::copy_construct_n	(	const T *	first,
		size_t	n,
		T *	result,
		int_to_type< true >
	)

        {
                assert(result >= first + n || result < first);
                Sys::MemCpy(result, first, n * sizeof(T));
        }

copy_n() [1/2]

template<typename T >

void std::internal::copy_n	(	const T *	first,
		size_t	n,
		T *	result,
		int_to_type< false >
	)

        {
                const T* last = first + n;
                switch (n & 0x3)
                {
                case 0:
                        while (first != last)
                        {
                                *result++ = *first++;
                case 3: *result++ = *first++;
                case 2: *result++ = *first++;
                case 1: *result++ = *first++;
                        }
                }
        }

copy_n() [2/2]

template<typename T >

void std::internal::copy_n	(	const T *	first,
		size_t	n,
		T *	result,
		int_to_type< true >
	)

        {
                assert(result >= first + n || result < first);
                Sys::MemCpy(result, first, n * sizeof(T));
        }

debug_pred()

template<typename T1 , typename T2 , class TPred >

bool std::internal::debug_pred ( const TPred &  pred, const T1 &  a, const T2 &  b  )

inline

        {
            return pred(a, b);
        }

destruct() [1/2]

template<typename T >

void std::internal::destruct	(	T *	mem,
		int_to_type< false >
	)

        {
                sizeof(mem);
                mem->~T();
        }

destruct() [2/2]

template<typename T >

void std::internal::destruct ( T *  , int_to_type< true >    )

inline

        {
                // Nothing to do, no destructor needed.
        }

destruct_n() [1/2]

template<typename T >

void std::internal::destruct_n	(	T *	first,
		size_t	n,
		int_to_type< false >
	)

        {
                sizeof(first);
                for (size_t i = 0; i < n; ++i)
                        (first + i)->~T();
        }

destruct_n() [2/2]

template<typename T >

void std::internal::destruct_n ( T *  , size_t  , int_to_type< true >    )

inline

        {
                // Nothing to do, no destructor needed.
        }

distance() [1/2]

template<typename TIter , typename TDist >

void std::internal::distance ( TIter  first, TIter  last, TDist &  dist, std::random_access_iterator_tag    )

inline

            {
                    dist = TDist(last - first);
            }

distance() [2/2]

template<typename TIter , typename TDist >

void std::internal::distance ( TIter  first, TIter  last, TDist &  dist, std::input_iterator_tag    )

inline

            {
                    dist = 0;
                    while (first != last)
                    {
                            ++dist;
                            ++first;
                    }
            }

down_heap()

template<typename T , class TPredicate >

void std::internal::down_heap	(	T *	data,
		size_t	k,
		size_t	n,
		TPredicate	pred
	)

        {
            const T temp = data[k - 1];
            while (k <= n / 2)
            {
                size_t child = 2 * k;
                if (child < n && pred(data[child - 1], data[child]))
                    ++child;
                if (pred(temp, data[child - 1]))
                {
                    data[k - 1] = data[child - 1];
                    k = child;
                }
                else
                    break;
            }
            data[k - 1] = temp;
        }

mod()

template<typename Tp , Tp m, Tp a = 1, Tp c = 0>

Tp std::internal::mod ( Tp  x )

inline

{ return mod<Tp, m, a, c>::calc(x); }

move() [1/2]

template<typename T >

void std::internal::move ( const T *  first, const T *  last, T *  result, int_to_type< false >    )

inline

        {
                result += (last - first);
                while (--last >= first)
                        *(--result) = *last;
        }

move() [2/2]

template<typename T >

void std::internal::move ( const T *  first, const T *  last, T *  result, int_to_type< true >    )

inline

        {

                const size_t n = reinterpret_cast<uintptr_t>(last) - reinterpret_cast<uintptr_t>(first);
                Sys::MemMove(result, first, n);
        }

move_n() [1/2]

template<typename T >

void std::internal::move_n ( const T *  from, size_t  n, T *  result, int_to_type< false >    )

inline

        {
                for (int i = int(n) - 1; i >= 0; --i)
                        result[i] = from[i];
        }

move_n() [2/2]

template<typename T >

void std::internal::move_n ( const T *  first, size_t  n, T *  result, int_to_type< true >    )

inline

        {
                Sys::MemMove(result, first, n * sizeof(T));
        }

quick_sort()

template<typename T , class TPredicate >

void std::internal::quick_sort	(	T *	data,
		long	low,
		long	high,
		TPredicate	pred
	)

        {
            while (true)
            {
                long i = low;
                long j = high;
                const T pivot = data[(low + high) >> 1];
                do
                {
                    // Jump over elements that are OK (smaller than pivot)
                    while (pred(data[i], pivot))
                        ++i;
                    // Jump over elements that are OK (greater than pivot)
                    while (pred(pivot, data[j]))
                        --j;
                    // Anything to swap?
                    if (j >= i)
                    {
                        if (i != j)
                        {
                            // Swap
                            T tmp(data[i]);
                            data[i] = data[j];
                            data[j] = tmp;
                        }
                    ++i;
                    --j;
                    }
                } while (i <= j);

            if (low < j)
                quick_sort(data, low, j, pred);

            if (i < high)
                low = i;    
            else
                break;
            } 
        }

test_ordering()

template<class TIter , class TPred >

void std::internal::test_ordering	(	TIter	first,
		TIter	last,
		const TPred &	pred
	)

        {
            sizeof(first); sizeof(last); sizeof(pred);
        }