pfc::list_impl_t< T, t_storage >

#include <list.h>

Inheritance diagram for pfc::list_impl_t< T, t_storage >:

Data Structures
class	sort_callback_wrapper

Public Types
typedef list_base_t< T >	t_base
typedef list_impl_t< T, t_storage >	t_self
Public Types inherited from pfc::list_base_const_t< T >
typedef T	t_item

Public Member Functions
	list_impl_t ()
	list_impl_t (const t_self &p_source)
template<typename t_in >
t_size	_insert_item_t (const t_in &item, t_size idx)
t_size	_insert_items_v (const list_base_const_t< T > &source, t_size base)
t_size	add_item (const T &item)
template<typename t_in >
t_size	add_item (const t_in &item)
template<typename t_in >
void	add_items (const t_in &in)
void	filter_mask (const bit_array &mask)
void	filter_mask (const bool *mask)
template<typename t_compare , typename t_permutation >
t_size	find_duplicates_sorted_permutation_t (t_compare p_compare, t_permutation p_permutation, bit_array_var &p_out)
template<typename t_compare >
t_size	find_duplicates_sorted_t (t_compare p_compare, bit_array_var &p_out) const
template<typename t_search >
t_size	find_item (const t_search &p_item) const
t_size	get_count () const
T	get_item (t_size n) const
void	get_item_ex (T &p_out, t_size n) const
const T &	get_item_ref (t_size n) const
void	get_items_mask (list_impl_t< T, t_storage > &out, const bit_array &mask)
const T *	get_ptr () const
T *	get_ptr ()
t_size	get_size () const
template<typename t_search >
bool	have_item (const t_search &p_item) const
template<typename t_in >
t_size	insert_item (const t_in &item, t_size idx)
t_size	insert_item (const T &item, t_size idx)
t_size	insert_items (const list_base_const_t< T > &source, t_size base)
t_size	insert_items (const list_base_t< T > &source, t_size base)
template<typename t_in >
t_size	insert_items (const t_in &source, t_size base)
void	move_from (t_self &other)
template<typename t_in >
t_self &	operator+= (t_in const &p_source)
template<typename t_in >
t_self &	operator= (t_in const &source)
const T &	operator[] (t_size n) const
T &	operator[] (t_size n)
template<typename t_in >
t_self &	operator|= (t_in const &p_source)
void	prealloc (t_size count)
void	remove_all ()
T	remove_by_idx (t_size idx)
void	remove_from_idx (t_size idx, t_size num)
void	remove_item (const T &item)
void	remove_mask (const bit_array &mask)
void	remove_mask (const bool *mask)
void	reorder_partial (t_size p_base, const t_size *p_order, t_size p_count)
void	replace_item (t_size idx, const T &item)
void	set_count (t_size p_count)
void	set_size (t_size p_count)
void	sort ()
void	sort (typename t_base::sort_callback &p_callback)
void	sort_stable (typename t_base::sort_callback &p_callback)
template<typename t_compare >
void	sort_stable_t (t_compare p_compare)
template<typename t_compare >
void	sort_t (t_compare p_compare)
void	swap_item_with (t_size p_index, T &p_item)
void	swap_items (t_size p_index1, t_size p_index2)
Public Member Functions inherited from pfc::list_base_t< T >
t_size	add_item (const T &item)
t_size	add_items (const list_base_const_t< T > &items)
t_size	add_items_fromptr (const T *source, t_size num)
t_size	add_items_repeat (T item, t_size num)
template<typename t_func >
void	for_each (t_func p_func)
template<typename t_func >
void	for_each (t_func p_func, const bit_array &p_mask)
t_size	insert_item (const T &item, t_size base)
t_size	insert_items_fromptr (const T *source, t_size num, t_size base)
t_size	insert_items_repeat (const T &item, t_size num, t_size base)
template<typename t_in >
t_self &	operator+= (t_in const &p_source)
template<typename t_in >
t_self &	operator= (t_in const &source)
T	operator[] (t_size n) const
template<typename t_in >
t_self &	operator|= (t_in const &p_source)
void	remove_all ()
template<typename t_releasefunc >
void	remove_all_ex (t_releasefunc p_func)
template<typename t_compare >
void	remove_duplicates_t (t_compare p_compare)
void	remove_mask (const bit_array &mask)
template<typename t_releasefunc >
void	remove_mask_ex (const bit_array &p_mask, t_releasefunc p_func)
void	reorder (const t_size *p_data)
T	replace_item_ex (t_size p_index, const T &p_item)
void	sort ()
template<typename t_compare >
void	sort_remove_duplicates_t (t_compare p_compare)
template<typename t_compare >
void	sort_stable_remove_duplicates_t (t_compare p_compare)
template<typename t_compare >
void	sort_stable_t (t_compare p_compare)
template<typename t_compare >
void	sort_t (t_compare p_compare)
void	truncate (t_size val)
Public Member Functions inherited from pfc::list_base_const_t< T >
template<typename t_compare , typename t_param , typename t_permutation >
bool	bsearch_permutation_t (t_compare p_compare, t_param const &p_param, const t_permutation &p_permutation, t_size &p_index) const
template<typename t_compare , typename t_param >
bool	bsearch_t (t_compare p_compare, t_param const &p_param, t_size &p_index) const
template<typename t_callback >
void	enumerate (t_callback &p_callback) const
template<typename t_compare , typename t_permutation >
t_size	find_duplicates_sorted_permutation_t (t_compare p_compare, t_permutation const &p_permutation, bit_array_var &p_out)
template<typename t_compare >
t_size	find_duplicates_sorted_t (t_compare p_compare, bit_array_var &p_out) const
template<typename t_search >
t_size	find_item (const t_search &p_item) const
T	get_item (t_size n) const
t_size	get_size () const
template<typename t_search >
bool	have_item (const t_search &p_item) const
bool	operator!= (const t_self &item2) const
bool	operator== (const t_self &item2) const
T	operator[] (t_size n) const
template<typename t_compare , typename t_permutation >
void	sort_get_permutation_t (t_compare p_compare, t_permutation const &p_permutation) const
template<typename t_compare , typename t_permutation >
void	sort_stable_get_permutation_t (t_compare p_compare, t_permutation const &p_permutation) const

Static Public Member Functions
static void	g_swap (list_impl_t< T, t_storage > &p_item1, list_impl_t< T, t_storage > &p_item2)
Static Public Member Functions inherited from pfc::list_base_const_t< T >
static bool	g_equals (const t_self &item1, const t_self &item2)

Protected Attributes
t_storage	m_buffer

Additional Inherited Members
Protected Member Functions inherited from pfc::list_base_t< T >
	list_base_t ()
	list_base_t (const t_self &)
	~list_base_t ()
void	operator= (const t_self &)
Protected Member Functions inherited from pfc::list_base_const_t< T >
	list_base_const_t ()
	list_base_const_t (const t_self &)
	~list_base_const_t ()
void	operator= (const t_self &)

Detailed Description

template<typename T, typename t_storage>
class pfc::list_impl_t< T, t_storage >

Definition at line 305 of file list.h.

Member Typedef Documentation

template<typename T, typename t_storage>

typedef list_base_t<T> pfc::list_impl_t< T, t_storage >::t_base

Definition at line 308 of file list.h.

template<typename T, typename t_storage>

typedef list_impl_t<T, t_storage> pfc::list_impl_t< T, t_storage >::t_self

Definition at line 309 of file list.h.

Constructor & Destructor Documentation

template<typename T, typename t_storage>

pfc::list_impl_t< T, t_storage >::list_impl_t ( )

inline

Definition at line 310 of file list.h.

{}

template<typename T, typename t_storage>

pfc::list_impl_t< T, t_storage >::list_impl_t ( const t_self &  p_source )

inline

Definition at line 311 of file list.h.

{ add_items(p_source); }

Member Function Documentation

template<typename T, typename t_storage>

template<typename t_in >

t_size pfc::list_impl_t< T, t_storage >::_insert_item_t ( const t_in &  item, t_size  idx  )

inline

Definition at line 319 of file list.h.

                                                         {
        return ::pfc::insert_t(m_buffer, item, idx);
    }

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::_insert_items_v ( const list_base_const_t< T > &  source, t_size  base  )

inline

Definition at line 385 of file list.h.

                                                                            { //workaround for inefficient operator[] on virtual-interface-accessed lists
        t_size count = get_size();
        if (base>count) base = count;
        t_size num = source.get_count();
        m_buffer.set_size(count+num);
        if (count > base) {
            for(t_size n=count-1;(int)n>=(int)base;n--) {
                ::pfc::move_t(m_buffer[n+num],m_buffer[n]);
            }
        }

        for(t_size n=0;n<num;n++) {
            source.get_item_ex(m_buffer[n+base],n);
        }
        return base;
    }

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::add_item ( const T &  item )

inline

Definition at line 522 of file list.h.

                                   {
        return insert_item(item, ~0);
    }

template<typename T, typename t_storage>

template<typename t_in >

t_size pfc::list_impl_t< T, t_storage >::add_item ( const t_in &  item )

inline

Definition at line 526 of file list.h.

                                                               {
        return insert_item(item, ~0);
    }

template<typename T, typename t_storage>

template<typename t_in >

void pfc::list_impl_t< T, t_storage >::add_items ( const t_in &  in )

inline

Definition at line 424 of file list.h.

{insert_items(in, ~0);}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::filter_mask ( const bit_array &  mask )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 433 of file list.h.

    {
        t_size n,count = get_size(), total = 0;

        n = total = mask.find(false,0,count);

        if (n<count) {
            for(n=mask.find(true,n+1,count-n-1);n<count;n=mask.find(true,n+1,count-n-1))
                ::pfc::move_t(m_buffer[total++],m_buffer[n]);

            m_buffer.set_size(total);
        }
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::filter_mask ( const bool *  mask )

inline

Definition at line 520 of file list.h.

{filter_mask(bit_array_table(mask,get_size()));}

template<typename T, typename t_storage>

template<typename t_compare , typename t_permutation >

t_size pfc::list_impl_t< T, t_storage >::find_duplicates_sorted_permutation_t ( t_compare  p_compare, t_permutation  p_permutation, bit_array_var &  p_out  )

inline

Definition at line 486 of file list.h.

    {
        return ::pfc::find_duplicates_sorted_permutation_t<list_impl_t<T,t_storage> const &,t_compare,t_permutation>(*this,get_size(),p_compare,p_permutation,p_out);
    }

template<typename T, typename t_storage>

template<typename t_compare >

t_size pfc::list_impl_t< T, t_storage >::find_duplicates_sorted_t ( t_compare  p_compare, bit_array_var &  p_out  ) const

inline

Definition at line 480 of file list.h.

    {
        return ::pfc::find_duplicates_sorted_t<list_impl_t<T,t_storage> const &,t_compare>(*this,get_size(),p_compare,p_out);
    }

template<typename T, typename t_storage>

template<typename t_search >

t_size pfc::list_impl_t< T, t_storage >::find_item ( const t_search &  p_item ) const

inline

Definition at line 560 of file list.h.

    {
        t_size n,max = get_size();
        for(n=0;n<max;n++)
            if (m_buffer[n]==p_item) return n;
        return ~0;
    }

template<typename T, typename t_storage>

static void pfc::list_impl_t< T, t_storage >::g_swap ( list_impl_t< T, t_storage > &  p_item1, list_impl_t< T, t_storage > &  p_item2  )

inlinestatic

Definition at line 554 of file list.h.

    {
        swap_t(p_item1.m_buffer,p_item2.m_buffer);
    }

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::get_count ( ) const

inlinevirtual

Implements pfc::list_base_const_t< T >.

Definition at line 365 of file list.h.

{return m_buffer.get_size();}

template<typename T, typename t_storage>

T pfc::list_impl_t< T, t_storage >::get_item ( t_size  n ) const

inline

Definition at line 358 of file list.h.

    {
        PFC_ASSERT(n >= 0);
        PFC_ASSERT(n < get_size() );
        return m_buffer[n];
    };

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::get_item_ex ( T &  p_out, t_size  n  ) const

inlinevirtual

Implements pfc::list_base_const_t< T >.

Definition at line 344 of file list.h.

    {
        PFC_ASSERT(n>=0);
        PFC_ASSERT(n<get_size());
        p_out = m_buffer[n];
    }

template<typename T, typename t_storage>

const T& pfc::list_impl_t< T, t_storage >::get_item_ref ( t_size  n ) const

inline

Definition at line 351 of file list.h.

    {
        PFC_ASSERT(n>=0);
        PFC_ASSERT(n<get_size());
        return m_buffer[n];
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::get_items_mask ( list_impl_t< T, t_storage > &  out, const bit_array &  mask  )

inline

Definition at line 426 of file list.h.

    {
        t_size n,count = get_size();
        for_each_bit_array(n,mask,true,0,count)
            out.add_item(m_buffer[n]);
    }

template<typename T, typename t_storage>

const T* pfc::list_impl_t< T, t_storage >::get_ptr ( ) const

inline

Definition at line 375 of file list.h.

{return m_buffer.get_ptr();}

template<typename T, typename t_storage>

T* pfc::list_impl_t< T, t_storage >::get_ptr ( )

inline

Definition at line 376 of file list.h.

{return m_buffer.get_ptr();}

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::get_size ( ) const

inline

Definition at line 366 of file list.h.

{return m_buffer.get_size();}

template<typename T, typename t_storage>

template<typename t_search >

bool pfc::list_impl_t< T, t_storage >::have_item ( const t_search &  p_item ) const

inline

Definition at line 569 of file list.h.

{return this->template find_item<t_search>(p_item)!=~0;}

template<typename T, typename t_storage>

template<typename t_in >

t_size pfc::list_impl_t< T, t_storage >::insert_item ( const t_in &  item, t_size  idx  )

inline

Definition at line 323 of file list.h.

                                                      {
        return _insert_item_t(item, idx);
    }

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::insert_item ( const T &  item, t_size  idx  )

inline

Definition at line 327 of file list.h.

                                                 {
        return _insert_item_t(item, idx);
    }

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::insert_items ( const list_base_const_t< T > &  source, t_size  base  )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 402 of file list.h.

{return _insert_items_v(source, base);}

template<typename T, typename t_storage>

t_size pfc::list_impl_t< T, t_storage >::insert_items ( const list_base_t< T > &  source, t_size  base  )

inline

Definition at line 403 of file list.h.

{return _insert_items_v(source, base);}

template<typename T, typename t_storage>

template<typename t_in >

t_size pfc::list_impl_t< T, t_storage >::insert_items ( const t_in &  source, t_size  base  )

inline

Definition at line 406 of file list.h.

                                                         {
        t_size count = get_size();
        if (base>count) base = count;
        t_size num = array_size_t(source);
        m_buffer.set_size(count+num);
        if (count > base) {
            for(t_size n=count-1;(int)n>=(int)base;n--) {
                ::pfc::move_t(m_buffer[n+num],m_buffer[n]);
            }
        }

        for(t_size n=0;n<num;n++) {
            m_buffer[n+base] = source[n];
        }
        return base;
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::move_from ( t_self &  other )

inline

Definition at line 492 of file list.h.

                                   {
        remove_all();
        m_buffer = std::move(other.m_buffer);
    }

template<typename T, typename t_storage>

template<typename t_in >

t_self& pfc::list_impl_t< T, t_storage >::operator+= ( t_in const &  p_source )

inline

Definition at line 572 of file list.h.

{add_item(p_source); return *this;}

template<typename T, typename t_storage>

template<typename t_in >

t_self& pfc::list_impl_t< T, t_storage >::operator= ( t_in const &  source )

inline

Definition at line 571 of file list.h.

{remove_all(); add_items(source); return *this;}

template<typename T, typename t_storage>

const T& pfc::list_impl_t< T, t_storage >::operator[] ( t_size  n ) const

inline

Definition at line 368 of file list.h.

    {
        PFC_ASSERT(n>=0);
        PFC_ASSERT(n<get_size());
        return m_buffer[n];
    }

template<typename T, typename t_storage>

T& pfc::list_impl_t< T, t_storage >::operator[] ( t_size  n )

inline

Definition at line 378 of file list.h.

{return m_buffer[n];}

template<typename T, typename t_storage>

template<typename t_in >

t_self& pfc::list_impl_t< T, t_storage >::operator|= ( t_in const &  p_source )

inline

Definition at line 573 of file list.h.

{add_items(p_source); return *this;}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::prealloc ( t_size  count )

inline

Definition at line 313 of file list.h.

{m_buffer.prealloc(count);}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::remove_all ( )

inline

Definition at line 530 of file list.h.

{remove_mask(bit_array_true());}

template<typename T, typename t_storage>

T pfc::list_impl_t< T, t_storage >::remove_by_idx ( t_size  idx )

inline

Definition at line 331 of file list.h.

    {
        T ret = m_buffer[idx];
        t_size n;
        t_size max = m_buffer.get_size();
        for(n=idx+1;n<max;n++) {
            ::pfc::move_t(m_buffer[n-1],m_buffer[n]);
        }
        m_buffer.set_size(max-1);
        return ret;
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::remove_from_idx ( t_size  idx, t_size  num  )

inline

Definition at line 380 of file list.h.

    {
        remove_mask(bit_array_range(idx,num));
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::remove_item ( const T &  item )

inline

Definition at line 532 of file list.h.

    {
        t_size n,max = get_size();
        bit_array_bittable mask(max);
        for(n=0;n<max;n++)
            mask.set(n,get_item(n)==item);
        remove_mask(mask);      
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::remove_mask ( const bit_array &  mask )

inline

Definition at line 517 of file list.h.

{filter_mask(bit_array_not(mask));}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::remove_mask ( const bool *  mask )

inline

Definition at line 519 of file list.h.

{remove_mask(bit_array_table(mask,get_size()));}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::reorder_partial ( t_size  p_base, const t_size *  p_order, t_size  p_count  )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 473 of file list.h.

    {
        PFC_ASSERT(p_base+p_count<=get_size());
        ::pfc::reorder_partial_t(m_buffer,p_base,p_order,p_count);
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::replace_item ( t_size  idx, const T &  item  )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 447 of file list.h.

    {
        PFC_ASSERT(idx>=0);
        PFC_ASSERT(idx<get_size());
        m_buffer[idx] = item;
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::set_count ( t_size  p_count )

inline

Definition at line 315 of file list.h.

{m_buffer.set_size(p_count);}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::set_size ( t_size  p_count )

inline

Definition at line 316 of file list.h.

{m_buffer.set_size(p_count);}

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::sort ( )

inline

Definition at line 454 of file list.h.

    {
        ::pfc::sort_callback_impl_auto_wrap_t<t_storage> wrapper(m_buffer);
        ::pfc::sort(wrapper,get_size());
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::sort ( typename t_base::sort_callback &  p_callback )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 507 of file list.h.

    {
        sort_t(sort_callback_wrapper(p_callback));
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::sort_stable ( typename t_base::sort_callback &  p_callback )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 512 of file list.h.

    {
        sort_stable_t(sort_callback_wrapper(p_callback));
    }

template<typename T, typename t_storage>

template<typename t_compare >

void pfc::list_impl_t< T, t_storage >::sort_stable_t ( t_compare  p_compare )

inline

Definition at line 468 of file list.h.

    {
        ::pfc::sort_callback_impl_simple_wrap_t<t_storage,t_compare> wrapper(m_buffer,p_compare);
        ::pfc::sort_stable(wrapper,get_size());
    }

template<typename T, typename t_storage>

template<typename t_compare >

void pfc::list_impl_t< T, t_storage >::sort_t ( t_compare  p_compare )

inline

Definition at line 461 of file list.h.

    {
        ::pfc::sort_callback_impl_simple_wrap_t<t_storage,t_compare> wrapper(m_buffer,p_compare);
        ::pfc::sort(wrapper,get_size());
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::swap_item_with ( t_size  p_index, T &  p_item  )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 541 of file list.h.

    {
        PFC_ASSERT(p_index < get_size());
        swap_t(m_buffer[p_index],p_item);
    }

template<typename T, typename t_storage>

void pfc::list_impl_t< T, t_storage >::swap_items ( t_size  p_index1, t_size  p_index2  )

inlinevirtual

Implements pfc::list_base_t< T >.

Definition at line 547 of file list.h.

    {
        PFC_ASSERT(p_index1 < get_size());
        PFC_ASSERT(p_index2 < get_size());
        swap_t(m_buffer[p_index1],m_buffer[p_index2]);
    }

Field Documentation

template<typename T, typename t_storage>

t_storage pfc::list_impl_t< T, t_storage >::m_buffer

protected

Definition at line 575 of file list.h.

---

The documentation for this class was generated from the following file:

• pfc/list.h