metadb_handle_list_helper Namespace Reference

Functions
t_size	bsearch_by_pointer (const pfc::list_base_const_t< metadb_handle_ptr > &p_list, const metadb_handle_ptr &val)
double	calc_total_duration (const pfc::list_base_const_t< metadb_handle_ptr > &p_list)
t_filesize	calc_total_size (metadb_handle_list_cref list, bool skipUnknown=false)
t_filesize	calc_total_size_ex (metadb_handle_list_cref list, bool &foundUnknown)
bool	extract_single_path (metadb_handle_list_cref list, const char *&path)
void	remove_duplicates (pfc::list_base_t< metadb_handle_ptr > &p_list)
void	sort_by_format (metadb_handle_list_ref p_list, const char *spec, titleformat_hook *p_hook)
void	sort_by_format (metadb_handle_list_ref p_list, const service_ptr_t< titleformat_object > &p_script, titleformat_hook *p_hook, int direction=1)
void	sort_by_format_get_order (metadb_handle_list_cref p_list, t_size *order, const char *spec, titleformat_hook *p_hook)
void	sort_by_format_get_order (metadb_handle_list_cref p_list, t_size *order, const service_ptr_t< titleformat_object > &p_script, titleformat_hook *p_hook, int p_direction=1)
void	sort_by_path (pfc::list_base_t< metadb_handle_ptr > &p_list)
void	sort_by_path_quick (pfc::list_base_t< metadb_handle_ptr > &p_list)
void	sort_by_pointer (pfc::list_base_t< metadb_handle_ptr > &p_list)
void	sort_by_pointer_remove_duplicates (pfc::list_base_t< metadb_handle_ptr > &p_list)
void	sort_by_relative_path (metadb_handle_list_ref p_list)
void	sort_by_relative_path_get_order (metadb_handle_list_cref p_list, t_size *order)
void	sorted_by_pointer_extract_difference (metadb_handle_list const &p_list_1, metadb_handle_list const &p_list_2, metadb_handle_list &p_list_1_specific, metadb_handle_list &p_list_2_specific)

Function Documentation

t_size metadb_handle_list_helper::bsearch_by_pointer	(	const pfc::list_base_const_t< metadb_handle_ptr > &	p_list,
		const metadb_handle_ptr &	val
	)

double metadb_handle_list_helper::calc_total_duration

(

const pfc::list_base_const_t< metadb_handle_ptr > &

p_list

)

t_filesize metadb_handle_list_helper::calc_total_size	(	metadb_handle_list_cref	list,
		bool	skipUnknown = false
	)

Definition at line 348 of file metadb_handle_list.cpp.

                                                                                                      {
    pfc::avltree_t< const char*, metadb::path_comparator > beenHere;
//  metadb_handle_list list(p_list);
//  list.sort_t(metadb::path_compare_metadb_handle);

    t_filesize ret = 0;
    t_size n, m = p_list.get_count();
    for(n=0;n<m;n++) {
        bool isNew;
        metadb_handle_ptr h; p_list.get_item_ex(h, n);
        beenHere.add_ex( h->get_path(), isNew);
        if (isNew) {
            t_filesize t = h->get_filesize();
            if (t == filesize_invalid) {
                if (!skipUnknown) return filesize_invalid;
            } else {
                ret += t;
            }
        }
    }
    return ret;
}

t_filesize metadb_handle_list_helper::calc_total_size_ex	(	metadb_handle_list_cref	list,
		bool &	foundUnknown
	)

Definition at line 371 of file metadb_handle_list.cpp.

                                                                                                            {
    foundUnknown = false;
    metadb_handle_list list(p_list);
    list.sort_t(metadb::path_compare_metadb_handle);

    t_filesize ret = 0;
    t_size n, m = list.get_count();
    for(n=0;n<m;n++) {
        if (n==0 || metadb::path_compare(list[n-1]->get_path(),list[n]->get_path())) {
            t_filesize t = list[n]->get_filesize();
            if (t == filesize_invalid) {
                foundUnknown = true;
            } else {
                ret += t;
            }
        }
    }
    return ret;
}

bool metadb_handle_list_helper::extract_single_path	(	metadb_handle_list_cref	list,
		const char *&	path
	)

Definition at line 391 of file metadb_handle_list.cpp.

                                                                                                       {
    const t_size total = list.get_count();
    if (total == 0) return false;
    const char * path = list[0]->get_path();
    for(t_size walk = 1; walk < total; ++walk) {
        if (metadb::path_compare(path, list[walk]->get_path()) != 0) return false;
    }
    pathOut = path;
    return true;
}

void metadb_handle_list_helper::remove_duplicates

(

pfc::list_base_t< metadb_handle_ptr > &

p_list

)

void metadb_handle_list_helper::sort_by_format	(	metadb_handle_list_ref	p_list,
		const char *	spec,
		titleformat_hook *	p_hook
	)

Definition at line 31 of file metadb_handle_list.cpp.

{
    service_ptr_t<titleformat_object> script;
    if (static_api_ptr_t<titleformat_compiler>()->compile(script,spec))
        sort_by_format(p_list,script,p_hook);
}

void metadb_handle_list_helper::sort_by_format	(	metadb_handle_list_ref	p_list,
		const service_ptr_t< titleformat_object > &	p_script,
		titleformat_hook *	p_hook,
		int	direction = 1
	)

Definition at line 45 of file metadb_handle_list.cpp.

{
    const t_size count = p_list.get_count();
    pfc::array_t<t_size> order; order.set_size(count);
    sort_by_format_get_order(p_list,order.get_ptr(),p_script,p_hook,direction);
    p_list.reorder(order.get_ptr());
}

void metadb_handle_list_helper::sort_by_format_get_order	(	metadb_handle_list_cref	p_list,
		t_size *	order,
		const char *	spec,
		titleformat_hook *	p_hook
	)

Definition at line 38 of file metadb_handle_list.cpp.

{
    service_ptr_t<titleformat_object> script;
    if (static_api_ptr_t<titleformat_compiler>()->compile(script,spec))
        sort_by_format_get_order(p_list,order,script,p_hook);
}

void metadb_handle_list_helper::sort_by_format_get_order	(	metadb_handle_list_cref	p_list,
		t_size *	order,
		const service_ptr_t< titleformat_object > &	p_script,
		titleformat_hook *	p_hook,
		int	p_direction = 1
	)

Definition at line 121 of file metadb_handle_list.cpp.

{
//  pfc::hires_timer timer; timer.start();

    const t_size count = p_list.get_count();
    pfc::array_t<custom_sort_data> data; data.set_size(count);
    
    {
        pfc::counter counter(0);
        pfc::array_t<pfc::rcptr_t<tfthread> > threads; threads.set_size(pfc::getOptimalWorkerThreadCountEx(p_list.get_count() / 128));
        PFC_ASSERT( threads.get_size() > 0 );
        for(t_size walk = 0; walk < threads.get_size(); ++walk) {
            threads[walk].new_t(&counter,p_list,data.get_ptr(),p_script,p_hook);
        }
        for(t_size walk = 1; walk < threads.get_size(); ++walk) threads[walk]->start();
        threads[0]->threadProc();
        for(t_size walk = 1; walk < threads.get_size(); ++walk) threads[walk]->waitTillDone();
    }
//  console::formatter() << "metadb_handle sort: prepared in " << pfc::format_time_ex(timer.query(),6);

    pfc::sort_t(data, p_direction > 0 ? custom_sort_compare<1> : custom_sort_compare<-1>,count);
    //qsort(data.get_ptr(),count,sizeof(custom_sort_data),p_direction > 0 ? _custom_sort_compare<1> : _custom_sort_compare<-1>);


//  console::formatter() << "metadb_handle sort: sorted in " << pfc::format_time_ex(timer.query(),6);

    for(t_size n=0;n<count;n++)
    {
        order[n]=data[n].index;
        delete[] data[n].text;
    }

//  console::formatter() << "metadb_handle sort: finished in " << pfc::format_time_ex(timer.query(),6);
}

void metadb_handle_list_helper::sort_by_path

(

pfc::list_base_t< metadb_handle_ptr > &

p_list

)

void metadb_handle_list_helper::sort_by_path_quick

(

pfc::list_base_t< metadb_handle_ptr > &

p_list

)

void metadb_handle_list_helper::sort_by_pointer

(

pfc::list_base_t< metadb_handle_ptr > &

p_list

)

void metadb_handle_list_helper::sort_by_pointer_remove_duplicates

(

pfc::list_base_t< metadb_handle_ptr > &

p_list

)

void metadb_handle_list_helper::sort_by_relative_path

(

metadb_handle_list_ref

p_list

)

Definition at line 156 of file metadb_handle_list.cpp.

{
    const t_size count = p_list.get_count();
    pfc::array_t<t_size> order; order.set_size(count);
    sort_by_relative_path_get_order(p_list,order.get_ptr());
    p_list.reorder(order.get_ptr());
}

void metadb_handle_list_helper::sort_by_relative_path_get_order	(	metadb_handle_list_cref	p_list,
		t_size *	order
	)

Definition at line 164 of file metadb_handle_list.cpp.

{
    const t_size count = p_list.get_count();
    t_size n;
    pfc::array_t<custom_sort_data> data;
    data.set_size(count);
    static_api_ptr_t<library_manager> api;
    
    pfc::string8_fastalloc temp;
    temp.prealloc(512);
    for(n=0;n<count;n++)
    {
        metadb_handle_ptr item;
        p_list.get_item_ex(item,n);
        if (!api->get_relative_path(item,temp)) temp = "";
        data[n].index = n;
        data[n].text = makeSortString(temp);
        //data[n].subsong = item->get_subsong_index();
    }

    pfc::sort_t(data,custom_sort_compare<1>,count);
    //qsort(data.get_ptr(),count,sizeof(custom_sort_data),(int (__cdecl *)(const void *elem1, const void *elem2 ))custom_sort_compare);

    for(n=0;n<count;n++)
    {
        order[n]=data[n].index;
        delete[] data[n].text;
    }
}

void metadb_handle_list_helper::sorted_by_pointer_extract_difference	(	metadb_handle_list const &	p_list_1,
		metadb_handle_list const &	p_list_2,
		metadb_handle_list &	p_list_1_specific,
		metadb_handle_list &	p_list_2_specific
	)

Definition at line 272 of file metadb_handle_list.cpp.

{
    t_size found_1, found_2;
    const t_size count_1 = p_list_1.get_count(), count_2 = p_list_2.get_count();
    t_size ptr_1, ptr_2;

    found_1 = found_2 = 0;
    ptr_1 = ptr_2 = 0;
    while(ptr_1 < count_1 || ptr_2 < count_2)
    {
        while(ptr_1 < count_1 && (ptr_2 == count_2 || p_list_1[ptr_1] < p_list_2[ptr_2]))
        {
            found_1++;
            t_size ptr_1_new = ptr_1 + 1;
            while(ptr_1_new < count_1 && p_list_1[ptr_1_new] == p_list_1[ptr_1]) ptr_1_new++;
            ptr_1 = ptr_1_new;
        }
        while(ptr_2 < count_2 && (ptr_1 == count_1 || p_list_2[ptr_2] < p_list_1[ptr_1]))
        {
            found_2++;
            t_size ptr_2_new = ptr_2 + 1;
            while(ptr_2_new < count_2 && p_list_2[ptr_2_new] == p_list_2[ptr_2]) ptr_2_new++;
            ptr_2 = ptr_2_new;
        }
        while(ptr_1 < count_1 && ptr_2 < count_2 && p_list_1[ptr_1] == p_list_2[ptr_2]) {ptr_1++; ptr_2++;}
    }

    

    p_list_1_specific.set_count(found_1);
    p_list_2_specific.set_count(found_2);
    if (found_1 > 0 || found_2 > 0)
    {
        found_1 = found_2 = 0;
        ptr_1 = ptr_2 = 0;

        while(ptr_1 < count_1 || ptr_2 < count_2)
        {
            while(ptr_1 < count_1 && (ptr_2 == count_2 || p_list_1[ptr_1] < p_list_2[ptr_2]))
            {
                p_list_1_specific[found_1++] = p_list_1[ptr_1];
                t_size ptr_1_new = ptr_1 + 1;
                while(ptr_1_new < count_1 && p_list_1[ptr_1_new] == p_list_1[ptr_1]) ptr_1_new++;
                ptr_1 = ptr_1_new;
            }
            while(ptr_2 < count_2 && (ptr_1 == count_1 || p_list_2[ptr_2] < p_list_1[ptr_1]))
            {
                p_list_2_specific[found_2++] = p_list_2[ptr_2];
                t_size ptr_2_new = ptr_2 + 1;
                while(ptr_2_new < count_2 && p_list_2[ptr_2_new] == p_list_2[ptr_2]) ptr_2_new++;
                ptr_2 = ptr_2_new;
            }
            while(ptr_1 < count_1 && ptr_2 < count_2 && p_list_1[ptr_1] == p_list_2[ptr_2]) {ptr_1++; ptr_2++;}
        }

    }
}

---

Generated by   1.8.9.1