haiku.git

#include "FilteredQuery.h"

#include <Debug.h>
#include <Entry.h>
#include <String.h>
#include <Volume.h>

// Helper function to copy a query.
// Used to avoid code duplication in
// TFilteredQuery(const BQuery &) and TFilteredQuery(const TFilteredQuery &)
static void
CopyQuery(const BQuery &query, BQuery *dest)
{
	ASSERT(dest);

	BQuery &nonConst = const_cast<BQuery &>(query);

	// BQuery doesn't have a copy constructor,
	// so we have to do the work ourselves...
	// Copy the predicate
	BString buffer;
	nonConst.GetPredicate(&buffer);
	dest->SetPredicate(buffer.String());

	// Copy the targetted volume
	BVolume volume(nonConst.TargetDevice());
	dest->SetVolume(&volume);
}


TFilteredQuery::TFilteredQuery()
{
}


TFilteredQuery::TFilteredQuery(const BQuery &query)
	:
	BQuery()
{
	CopyQuery(query, this);
}


TFilteredQuery::TFilteredQuery(const TFilteredQuery &query)
	:
	BQuery()
{
	CopyQuery(query, this);

	// copy filters
	fFilters = query.fFilters;
}


TFilteredQuery::~TFilteredQuery()
{
	Clear();
}


bool
TFilteredQuery::AddFilter(filter_function filter, void *arg)
{
	filter_pair *filterPair = new filter_pair(filter, arg);

	return fFilters.AddItem(filterPair);
}


void
TFilteredQuery::RemoveFilter(filter_function function)
{
	int32 count = fFilters.CountItems();
	for (int32 i = 0; i < count; i++) {
		filter_pair *pair = fFilters.ItemAt(i);
		if (pair->filter == function) {
			delete fFilters.RemoveItemAt(i);
			break;
		}
	}
}


status_t
TFilteredQuery::GetNextRef(entry_ref *ref)
{
	entry_ref tmpRef;
	status_t result;

	int32 filterCount = fFilters.CountItems();
	while ((result = BQuery::GetNextRef(&tmpRef)) == B_OK) {
		bool accepted = true;
		// We have a match, so let the entry_ref go through the filters
		// and see if it passes all the requirements
		for (int32 i = 0; i < filterCount; i++) {
			filter_pair *pair = fFilters.ItemAt(i);
			filter_function filter = pair->filter;
			accepted = (*filter)(&tmpRef, pair->args);
			if (!accepted)
				break;
		}

		if (accepted) {
			// Ok, this entry_ref passed all tests
			*ref = tmpRef;
			break;
		}
	}

	return result;
}


status_t
TFilteredQuery::GetNextEntry(BEntry *entry, bool traverse)
{
	// This code is almost a full copy/paste from Haiku's
	// BQuery::GetNextEntry(BEntry *entry, bool traverse)

	entry_ref ref;
	status_t error = GetNextRef(&ref);
	if (error == B_OK)
		error = entry->SetTo(&ref, traverse);

	return error;
}


status_t
TFilteredQuery::Clear()
{
	int32 filtersCount = fFilters.CountItems();
	for (int32 i = 0; i < filtersCount; i++)
		delete fFilters.RemoveItemAt(i);

	return BQuery::Clear();
}