tpie::ami::Internal_Sorter_Obj< T, Compare > Class Template Reference

Comparision object based Internal_Sorter_base subclass implementation; uses quick_sort_obj(). More...

#include <tpie/internal_sort.h>

Inherits tpie::ami::Internal_Sorter_Base< T >.

Public Member Functions
	Internal_Sorter_Obj (Compare cmp)
	Empty constructor. More...
	~Internal_Sorter_Obj ()
	Empty destructor. More...
void	sort (file_stream< T > *InStr, file_stream< T > *OutStr, TPIE_OS_SIZE_T nItems, progress_indicator_base *pi=0)
	Reads nItems sequentially from InStr, starting at the current file position; writes the sorted output to OutStr, starting from the current file position. More...
void	allocate (TPIE_OS_SIZE_T nItems)
	Allocate ItemArray as array that can hold nItems. More...
void	deallocate (void)
	Clean up internal array ItemArray. More...
TPIE_OS_SIZE_T	MaxItemCount (TPIE_OS_SIZE_T memSize)
	Returns maximum number of items that can be sorted using memSize bytes. More...
TPIE_OS_SIZE_T	space_per_item ()
	Returns memory usage in bytes per sort item. More...
TPIE_OS_SIZE_T	space_overhead ()
	Returns fixed memory usage overhead in bytes per class instantiation. More...

Protected Attributes
Compare	cmp_o
	Comparison object used for sorting. More...
array< T >	ItemArray
	Array that holds items to be sorted. More...
TPIE_OS_SIZE_T	len
	length of ItemArray More...

Detailed Description

template<class T, class Compare>
class tpie::ami::Internal_Sorter_Obj< T, Compare >

Comparision object based Internal_Sorter_base subclass implementation; uses quick_sort_obj().

Definition at line 166 of file internal_sort.h.

Constructor & Destructor Documentation

template<class T, class Compare>

tpie::ami::Internal_Sorter_Obj< T, Compare >::Internal_Sorter_Obj ( Compare  cmp )

inline

Empty constructor.

Definition at line 177 of file internal_sort.h.

:cmp_o(cmp) {};

template<class T, class Compare>

tpie::ami::Internal_Sorter_Obj< T, Compare >::~Internal_Sorter_Obj ( )

inline

Empty destructor.

Definition at line 182 of file internal_sort.h.

{};

Member Function Documentation

template<class T >

void tpie::ami::Internal_Sorter_Base< T >::allocate ( TPIE_OS_SIZE_T  nItems )

inlineinherited

Allocate ItemArray as array that can hold nItems.

Definition at line 128 of file internal_sort.h.

                                                                   {
    len=nitems;
    ItemArray.resize(len);
}

template<class T >

void tpie::ami::Internal_Sorter_Base< T >::deallocate ( void  )

inlineinherited

Clean up internal array ItemArray.

Definition at line 134 of file internal_sort.h.

                                                    {
    ItemArray.resize(0);
    len=0;
}

template<class T >

TPIE_OS_SIZE_T tpie::ami::Internal_Sorter_Base< T >::MaxItemCount ( TPIE_OS_SIZE_T  memSize )

inlineinherited

Returns maximum number of items that can be sorted using memSize bytes.

Definition at line 140 of file internal_sort.h.

                                                                                  {
    //Space available for items
    TPIE_OS_SIZE_T memAvail=memSize-space_overhead();
    
    if (memAvail < space_per_item()) return 0; 
    return memAvail/space_per_item(); 
}

template<class T , class Compare >

void tpie::ami::Internal_Sorter_Obj< T, Compare >::sort	(	file_stream< T > *	InStr,
		file_stream< T > *	OutStr,
		TPIE_OS_SIZE_T	nItems,
		progress_indicator_base *	pi = 0
	)

Reads nItems sequentially from InStr, starting at the current file position; writes the sorted output to OutStr, starting from the current file position.

Definition at line 202 of file internal_sort.h.

References tpie::fractional_subindicator::done(), tpie::fractional_progress::done(), tpie::fractional_progress::id(), tpie::fractional_subindicator::init(), tpie::fractional_progress::init(), tpie::file_stream< T >::read(), tpie::file_stream< T >::seek(), tpie::progress_indicator_base::step(), tp_assert, TPIE_FSI, and tpie::file_stream< T >::truncate().

                                                                         {
    tp_assert ( nItems <= len, "Internal buffer overfull (nItems > len)");

    
    TPIE_OS_SIZE_T i = 0;
    
    //make sure we called allocate earlier
    if (ItemArray.size() == 0) throw stream_exception("NULL_POINTER");
        
    tp_assert ( nItems <= len, "Internal buffer overfull (nItems > len)");

    fractional_progress fp(pi);
    fp.id() << __FILE__ << __FUNCTION__ << typeid(T) << typeid(Compare);
    fractional_subindicator read_progress(fp, "read", TPIE_FSI, nItems, "Reading");
    fractional_subindicator sort_progress(fp, "sort", TPIE_FSI, nItems, "Sorting");
    fractional_subindicator write_progress(fp, "write", TPIE_FSI, nItems, "Writing");
    fp.init();

    read_progress.init(nItems);
    // Read a memory load out of the input stream one item at a time,
    for (i = 0; i < nItems; i++) {
        ItemArray[i] = InStr->read();
        read_progress.step();
    }
    read_progress.done();

    //Sort the array.
    tpie::parallel_sort<true>(ItemArray.begin(), ItemArray.begin()+nItems, sort_progress, cmp_o);
    if (InStr==OutStr) { //Do the right thing if we are doing 2x sort
        //Internal sort objects should probably be re-written so that
        //the interface is cleaner and they don't have to worry about I/O
        InStr->truncate(0); //delete original items
        InStr->seek(0); //rewind
    }

    write_progress.init(nItems);
    //Write sorted array to OutStr
    for (i = 0; i < nItems; i++) {
        OutStr->write(ItemArray[i]);
        write_progress.step();
    }
    write_progress.done();
    fp.done();
}

template<class T >

TPIE_OS_SIZE_T tpie::ami::Internal_Sorter_Base< T >::space_overhead ( void  )

inlineinherited

Returns fixed memory usage overhead in bytes per class instantiation.

Definition at line 150 of file internal_sort.h.

                                                                  {
    // Space usage independent of space_per_item
    // accounts MM_manager space overhead on "new" call
    return 0;
}

template<class T >

TPIE_OS_SIZE_T tpie::ami::Internal_Sorter_Base< T >::space_per_item ( void  )

inlineinherited

Returns memory usage in bytes per sort item.

Definition at line 157 of file internal_sort.h.

                                                                  {
    return sizeof(T);
}

Member Data Documentation

template<class T, class Compare>

Compare tpie::ami::Internal_Sorter_Obj< T, Compare >::cmp_o

protected

Comparison object used for sorting.

Definition at line 171 of file internal_sort.h.

template<class T>

array<T> tpie::ami::Internal_Sorter_Base< T >::ItemArray

protectedinherited

Array that holds items to be sorted.

Definition at line 82 of file internal_sort.h.

template<class T>

TPIE_OS_SIZE_T tpie::ami::Internal_Sorter_Base< T >::len

protectedinherited

length of ItemArray

Definition at line 84 of file internal_sort.h.

---

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

• internal_sort.h