pfc::array_t< _t_item, t_alloc >

#include <array.h>

Public Types
typedef _t_item	t_item

Public Member Functions
	array_t ()
	array_t (const t_self &p_source)
template<typename t_source >
	array_t (const t_source &p_source)
	array_t (t_self &&p_source)
template<typename t_array >
void	append (const t_array &p_source)
template<typename t_append >
void	append_fromptr (const t_append *p_buffer, t_size p_count)
template<typename t_append >
void	append_multi (const t_append &value, t_size count)
template<typename t_append >
void	append_single (const t_append &p_item)
template<typename t_append >
void	append_single_val (t_append item)
template<typename t_callback >
void	enumerate (t_callback &p_callback) const
template<typename t_filler >
void	fill (const t_filler &p_filler)
void	fill_null ()
void	force_reset ()
t_size	get_count () const
const t_item *	get_ptr () const
t_item *	get_ptr ()
t_size	get_size () const
void	grow_size (t_size p_size)
template<typename t_array >
bool	has_owned_items (const t_array &p_source)
void	increase_size (t_size p_delta)
template<typename t_insert >
void	insert_multi (const t_insert &value, t_size base, t_size count)
template<typename t_source >
bool	is_owned (const t_source &p_item)
void	move_from (t_self &other)
const t_self &	operator= (const t_self &p_source)
template<typename t_source >
const t_self &	operator= (const t_source &p_source)
const t_self &	operator= (t_self &&p_source)
const t_item &	operator[] (t_size p_index) const
t_item &	operator[] (t_size p_index)
void	prealloc (t_size p_size)
void	set_count (t_size p_count)
template<typename t_source >
void	set_data_fromptr (const t_source *p_buffer, t_size p_count)
template<typename t_item >
void	set_single (const t_item &p_item)
void	set_size (t_size p_size)
void	set_size_discard (t_size p_size)
template<typename fill_t >
void	set_size_fill (size_t p_size, fill_t const &filler)
void	set_size_in_range (size_t minSize, size_t maxSize)

Private Types
typedef array_t< t_item, t_alloc >	t_self

Private Attributes
t_alloc< t_item >	m_alloc

Detailed Description

template<typename _t_item, template< typename > class t_alloc>
class pfc::array_t< _t_item, t_alloc >

Definition at line 6 of file array.h.

Member Typedef Documentation

template<typename _t_item, template< typename > class t_alloc>

typedef _t_item pfc::array_t< _t_item, t_alloc >::t_item

Definition at line 92 of file array.h.

template<typename _t_item, template< typename > class t_alloc>

typedef array_t<t_item,t_alloc> pfc::array_t< _t_item, t_alloc >::t_self

private

Definition at line 93 of file array.h.

Constructor & Destructor Documentation

template<typename _t_item, template< typename > class t_alloc>

pfc::array_t< _t_item, t_alloc >::array_t ( )

inline

Definition at line 95 of file array.h.

{}

template<typename _t_item, template< typename > class t_alloc>

pfc::array_t< _t_item, t_alloc >::array_t ( const t_self &  p_source )

inline

Definition at line 96 of file array.h.

{copy_array_t(*this,p_source);}

template<typename _t_item, template< typename > class t_alloc>

template<typename t_source >

pfc::array_t< _t_item, t_alloc >::array_t ( const t_source &  p_source )

inline

Definition at line 97 of file array.h.

{copy_array_t(*this,p_source);}

template<typename _t_item, template< typename > class t_alloc>

pfc::array_t< _t_item, t_alloc >::array_t ( t_self &&  p_source )

inline

Definition at line 101 of file array.h.

{move_from(p_source);}

Member Function Documentation

template<typename _t_item, template< typename > class t_alloc>

template<typename t_array >

void pfc::array_t< _t_item, t_alloc >::append ( const t_array &  p_source )

inline

Definition at line 145 of file array.h.

                                              {
            if (has_owned_items(p_source)) append(array_t<t_item>(p_source));
            else {
                const t_size source_size = array_size_t(p_source);
                const t_size base = get_size();
                increase_size(source_size);
                for(t_size n=0;n<source_size;n++) m_alloc[base+n] = p_source[n];
            }
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_append >

void pfc::array_t< _t_item, t_alloc >::append_fromptr ( const t_append *  p_buffer, t_size  p_count  )

inline

Warning: buffer pointer must not point to buffer allocated by this array (fixme).

Definition at line 167 of file array.h.

                                                                      {
            PFC_ASSERT( !is_owned(&p_buffer[0]) );
            t_size base = get_size();
            increase_size(p_count);
            for(t_size n=0;n<p_count;n++) m_alloc[base+n] = p_buffer[n];
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_append >

void pfc::array_t< _t_item, t_alloc >::append_multi ( const t_append &  value, t_size  count  )

inline

Definition at line 163 of file array.h.

{insert_multi(value,~0,count);}

template<typename _t_item, template< typename > class t_alloc>

template<typename t_append >

void pfc::array_t< _t_item, t_alloc >::append_single ( const t_append &  p_item )

inline

Definition at line 188 of file array.h.

                                                    {
            if (is_owned(p_item)) append_single(t_append(p_item));
            else {
                const t_size base = get_size();
                increase_size(1);
                m_alloc[base] = p_item;
            }
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_append >

void pfc::array_t< _t_item, t_alloc >::append_single_val ( t_append  item )

inline

Definition at line 181 of file array.h.

                                                {
            const t_size base = get_size();
            increase_size(1);
            m_alloc[base] = item;
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_callback >

void pfc::array_t< _t_item, t_alloc >::enumerate ( t_callback &  p_callback ) const

inline

Definition at line 240 of file array.h.

{ for(t_size n = 0; n < get_size(); n++ ) { p_callback((*this)[n]); } }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_filler >

void pfc::array_t< _t_item, t_alloc >::fill ( const t_filler &  p_filler )

inline

Definition at line 198 of file array.h.

                                             {
            const t_size max = get_size();
            for(t_size n=0;n<max;n++) m_alloc[n] = p_filler;
        }

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::fill_null ( )

inline

Definition at line 203 of file array.h.

                         {
            const t_size max = get_size();
            for(t_size n=0;n<max;n++) m_alloc[n] = 0;
        }

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::force_reset ( )

inline

Definition at line 132 of file array.h.

{m_alloc.force_reset();}

template<typename _t_item, template< typename > class t_alloc>

t_size pfc::array_t< _t_item, t_alloc >::get_count ( ) const

inline

Definition at line 131 of file array.h.

{return m_alloc.get_size();}

template<typename _t_item, template< typename > class t_alloc>

const t_item* pfc::array_t< _t_item, t_alloc >::get_ptr ( ) const

inline

Definition at line 213 of file array.h.

{return m_alloc.get_ptr();}

template<typename _t_item, template< typename > class t_alloc>

t_item* pfc::array_t< _t_item, t_alloc >::get_ptr ( )

inline

Definition at line 214 of file array.h.

{return m_alloc.get_ptr();}

template<typename _t_item, template< typename > class t_alloc>

t_size pfc::array_t< _t_item, t_alloc >::get_size ( ) const

inline

Definition at line 130 of file array.h.

{return m_alloc.get_size();}

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::grow_size ( t_size  p_size )

inline

Definition at line 208 of file array.h.

                                      {
            if (p_size > get_size()) set_size(p_size);
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_array >

bool pfc::array_t< _t_item, t_alloc >::has_owned_items ( const t_array &  p_source )

inline

Definition at line 219 of file array.h.

                                                       {
            if (array_size_t(p_source) == 0) return false;

            //how the hell would we properly check if any of source items is owned by us, in case source array implements some weird mixing of references of items from different sources?
            //the most obvious way means evil bottleneck here (whether it matters or not from caller's point of view which does something O(n) already is another question)
            //at least this will work fine with all standard classes which don't crossreference anyhow and always use own storage
            //perhaps we'll traitify this someday later
            return is_owned(p_source[0]);
        }

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::increase_size ( t_size  p_delta )

inline

Definition at line 174 of file array.h.

                                           {
            t_size new_size = get_size() + p_delta;
            if (new_size < p_delta) throw std::bad_alloc();
            set_size(new_size);
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_insert >

void pfc::array_t< _t_item, t_alloc >::insert_multi ( const t_insert &  value, t_size  base, t_size  count  )

inline

Definition at line 156 of file array.h.

                                                                             {
            const t_size oldSize = get_size();
            if (base > oldSize) base = oldSize;
            increase_size(count);
            pfc::memmove_t(get_ptr() + base + count, get_ptr() + base, oldSize - base);
            pfc::fill_ptr_t(get_ptr() + base, count, value);
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_source >

bool pfc::array_t< _t_item, t_alloc >::is_owned ( const t_source &  p_item )

inline

Definition at line 230 of file array.h.

                                               {
            return m_alloc.is_ptr_owned(&p_item);
        }

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::move_from ( t_self &  other )

inline

Definition at line 242 of file array.h.

                                       {
            m_alloc.move_from(other.m_alloc);
        }

template<typename _t_item, template< typename > class t_alloc>

const t_self& pfc::array_t< _t_item, t_alloc >::operator= ( const t_self &  p_source )

inline

Definition at line 98 of file array.h.

{copy_array_t(*this,p_source); return *this;}

template<typename _t_item, template< typename > class t_alloc>

template<typename t_source >

const t_self& pfc::array_t< _t_item, t_alloc >::operator= ( const t_source &  p_source )

inline

Definition at line 99 of file array.h.

{copy_array_t(*this,p_source); return *this;}

template<typename _t_item, template< typename > class t_alloc>

const t_self& pfc::array_t< _t_item, t_alloc >::operator= ( t_self &&  p_source )

inline

Definition at line 102 of file array.h.

{move_from(p_source); return *this;}

template<typename _t_item, template< typename > class t_alloc>

const t_item& pfc::array_t< _t_item, t_alloc >::operator[] ( t_size  p_index ) const

inline

Definition at line 134 of file array.h.

{PFC_ASSERT(p_index < get_size());return m_alloc[p_index];}

template<typename _t_item, template< typename > class t_alloc>

t_item& pfc::array_t< _t_item, t_alloc >::operator[] ( t_size  p_index )

inline

Definition at line 135 of file array.h.

{PFC_ASSERT(p_index < get_size());return m_alloc[p_index];}

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::prealloc ( t_size  p_size )

inline

Definition at line 216 of file array.h.

{m_alloc.prealloc(p_size);}

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::set_count ( t_size  p_count )

inline

Definition at line 129 of file array.h.

{m_alloc.set_size(p_count);}

template<typename _t_item, template< typename > class t_alloc>

template<typename t_source >

void pfc::array_t< _t_item, t_alloc >::set_data_fromptr ( const t_source *  p_buffer, t_size  p_count  )

inline

Warning: buffer pointer must not point to buffer allocated by this array (fixme).

Definition at line 139 of file array.h.

                                                                        {
            set_size(p_count);
            pfc::copy_array_loop_t(*this,p_buffer,p_count);
        }

template<typename _t_item, template< typename > class t_alloc>

template<typename t_item >

void pfc::array_t< _t_item, t_alloc >::set_single ( const t_item &  p_item )

inline

Definition at line 235 of file array.h.

                                               {
            set_size(1);
            (*this)[0] = p_item;
        }

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::set_size ( t_size  p_size )

inline

Definition at line 104 of file array.h.

{m_alloc.set_size(p_size);}

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::set_size_discard ( t_size  p_size )

inline

Definition at line 128 of file array.h.

{m_alloc.set_size(p_size);}

template<typename _t_item, template< typename > class t_alloc>

template<typename fill_t >

void pfc::array_t< _t_item, t_alloc >::set_size_fill ( size_t  p_size, fill_t const &  filler  )

inline

Definition at line 107 of file array.h.

                                                                 {
            size_t before = get_size();
            set_size( p_size );
            for(size_t w = before; w < p_size; ++w) this->get_ptr()[w] = filler;
        }

template<typename _t_item, template< typename > class t_alloc>

void pfc::array_t< _t_item, t_alloc >::set_size_in_range ( size_t  minSize, size_t  maxSize  )

inline

Definition at line 113 of file array.h.

                                                               {
            if (minSize >= maxSize) { set_size( minSize); return; }
            size_t walk = maxSize;
            for(;;) {
                try {
                    set_size(walk);
                    return;
                } catch(std::bad_alloc) {
                    if (walk <= minSize) throw;
                    // go on
                }
                walk >>= 1;
                if (walk < minSize) walk = minSize;
            }
        }

Field Documentation

template<typename _t_item, template< typename > class t_alloc>

t_alloc<t_item> pfc::array_t< _t_item, t_alloc >::m_alloc

private

Definition at line 246 of file array.h.

---

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

• pfc/array.h