order_helper

#include <order_helper.h>

Public Member Functions
	order_helper (t_size p_size)
	order_helper (const order_helper &p_order)
t_size	find_reverse (t_size val)
t_size	get_count () const
t_size	get_item (t_size ptr) const
const t_size *	get_ptr () const
t_size &	operator[] (t_size ptr)
t_size	operator[] (t_size ptr) const
void	reverse (t_size base, t_size count)
void	swap (t_size ptr1, t_size ptr2)

Static Public Member Functions
template<typename t_int >
static void	g_fill (t_int *p_order, const t_size p_count)
template<typename t_array >
static void	g_fill (t_array &p_array)
static t_size	g_find_reverse (const t_size *order, t_size val)
static bool	g_is_identity (const t_size *order, t_size count)
template<typename t_array >
static bool	g_is_identity (const t_array &p_array)
static void	g_reverse (t_size *order, t_size base, t_size count)
static void	g_swap (t_size *p_data, t_size ptr1, t_size ptr2)

Private Attributes
pfc::array_t< t_size >	m_data

Detailed Description

Definition at line 14 of file order_helper.h.

Constructor & Destructor Documentation

order_helper::order_helper ( t_size  p_size )

inline

Definition at line 18 of file order_helper.h.

                                {
        m_data.set_size(p_size);
        for(t_size n=0;n<p_size;n++) m_data[n]=n;
    }

order_helper::order_helper ( const order_helper &  p_order )

inline

Definition at line 23 of file order_helper.h.

{*this = p_order;}

Member Function Documentation

t_size order_helper::find_reverse ( t_size  val )

inline

Insecure - may deadlock or crash on invalid permutation content. In theory faster than walking the permutation, but still O(n).

Definition at line 62 of file order_helper.h.

{return g_find_reverse(m_data.get_ptr(),val);}

template<typename t_int >

static void order_helper::g_fill ( t_int *  p_order, const t_size  p_count  )

inlinestatic

Definition at line 38 of file order_helper.h.

                                                             {
        t_size n; for(n=0;n<p_count;n++) p_order[n] = (t_int)n;
    }

template<typename t_array >

static void order_helper::g_fill ( t_array &  p_array )

inlinestatic

Definition at line 43 of file order_helper.h.

                                          {
        t_size n; const t_size max = pfc::array_size_t(p_array);
        for(n=0;n<max;n++) p_array[n] = n;
    }

t_size order_helper::g_find_reverse ( const t_size *  order, t_size  val  )

static

Insecure - may deadlock or crash on invalid permutation content. In theory faster than walking the permutation, but still O(n).

Definition at line 90 of file other.cpp.

{
    t_size prev = val, next = order[val];
    while(next != val)
    {
        prev = next;
        next = order[next];
    }
    return prev;
}

static bool order_helper::g_is_identity ( const t_size *  order, t_size  count  )

inlinestatic

Definition at line 25 of file order_helper.h.

                                                                  {
        for(t_size walk = 0; walk < count; ++walk) {
            if (order[walk] != walk) return false;
        }
        return true;
    }

template<typename t_array >

static bool order_helper::g_is_identity ( const t_array &  p_array )

inlinestatic

Definition at line 31 of file order_helper.h.

                                                                                  {
        const t_size count = pfc::array_size_t(p_array);
        for(t_size walk = 0; walk < count; ++walk) if (p_array[walk] != walk) return false;
        return true;
    }

void order_helper::g_reverse ( t_size *  order, t_size  base, t_size  count  )

static

Definition at line 102 of file other.cpp.

{
    t_size max = count>>1;
    t_size n;
    t_size base2 = base+count-1;
    for(n=0;n<max;n++)
        g_swap(order,base+n,base2-n);
}

void order_helper::g_swap ( t_size *  p_data, t_size  ptr1, t_size  ptr2  )

static

Definition at line 82 of file other.cpp.

{
    t_size temp = data[ptr1];
    data[ptr1] = data[ptr2];
    data[ptr2] = temp;
}

t_size order_helper::get_count ( ) const

inline

Definition at line 67 of file order_helper.h.

{return m_data.get_size();}

t_size order_helper::get_item ( t_size  ptr ) const

inline

Definition at line 49 of file order_helper.h.

{return m_data[ptr];}

const t_size* order_helper::get_ptr ( ) const

inline

Definition at line 57 of file order_helper.h.

{return m_data.get_ptr();}

t_size& order_helper::operator[] ( t_size  ptr )

inline

Definition at line 51 of file order_helper.h.

{return m_data[ptr];}

t_size order_helper::operator[] ( t_size  ptr ) const

inline

Definition at line 52 of file order_helper.h.

{return m_data[ptr];}

void order_helper::reverse ( t_size  base, t_size  count  )

inline

Definition at line 65 of file order_helper.h.

{g_reverse(m_data.get_ptr(),base,count);}

void order_helper::swap ( t_size  ptr1, t_size  ptr2  )

inline

Definition at line 55 of file order_helper.h.

{pfc::swap_t(m_data[ptr1],m_data[ptr2]);}

Field Documentation

pfc::array_t<t_size> order_helper::m_data

private

Definition at line 16 of file order_helper.h.

---

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

• pfc/order_helper.h
• pfc/other.cpp