FilterSearch Class Reference

#include <FilterSearch.hh>

Inheritance diagram for FilterSearch:

Collaboration diagram for FilterSearch:

Classes
class	Cache

Public Member Functions
	FilterSearch ()
virtual	~FilterSearch ()
SearchStrategy *	copy () const
CostDBTypes::EntryTable	search (const CostDBEntryKey &searchKey, CostDBTypes::EntryTable components, const CostDBTypes::MatchTypeTable &match)
Public Member Functions inherited from SearchStrategy
virtual	~SearchStrategy ()

Private Types
typedef std::vector< Cache * >	CacheTable
	Table of cache entries. More...
typedef std::vector< Matcher * >	MatcherTable
	Table of matcher types. More...

Private Member Functions
CostDBTypes::EntryTable	findFromCache (const CostDBEntryKey &searchKey, const CostDBTypes::MatchTypeTable &match)
MatcherTable	createMatchers (const CostDBTypes::MatchTypeTable &match)
	FilterSearch (const FilterSearch &)
	Copying not allowed. More...
FilterSearch &	operator= (const FilterSearch &)
	Assignment not allowed. More...

Private Attributes
CacheTable	entryCache_
	Results of the previous queries. More...
MatcherTable	matcherStorage_
	Storage for all matchers. They cannot be deleted before search strategy itself is deleted. Thus, this storage exists to deallocate the memory reserved by matchers. More...

Detailed Description

Implementation of the queries from the cost database.

Using the FilterSearch algorithm requires only a Search() function call.

Search is based on filtering non-matching entries out according to information of one field at a time. Thus, it is very generic accepting field changes to entries without touching to the searrch algorithms.

Cache and quick filtering is used for optimisation. Cache contains all the results from the previous queries. Quick filtering removes unneccessary entries in linear time in the beginning of the search.

Definition at line 63 of file FilterSearch.hh.

Member Typedef Documentation

CacheTable

typedef std::vector<Cache*> FilterSearch::CacheTable

private

Table of cache entries.

Definition at line 106 of file FilterSearch.hh.

MatcherTable

typedef std::vector<Matcher*> FilterSearch::MatcherTable

private

Table of matcher types.

Definition at line 108 of file FilterSearch.hh.

Constructor & Destructor Documentation

FilterSearch() [1/2]

FilterSearch::FilterSearch

(

)

Default constructor.

Definition at line 47 of file FilterSearch.cc.

                           {
}

Referenced by copy().

~FilterSearch()

FilterSearch::~FilterSearch ( )

virtual

Destructor.

Definition at line 53 of file FilterSearch.cc.

                            {
    
    for (CacheTable::iterator i = entryCache_.begin();
         i != entryCache_.end(); i++) {
        
        assert(*i != NULL);
        delete *i;
        *i = NULL;
    }
    for (MatcherTable::iterator i = matcherStorage_.begin();
         i != matcherStorage_.end(); i++) {
        
        assert(*i != NULL);
        delete *i;
        *i = NULL;
    }
}

References assert, entryCache_, and matcherStorage_.

FilterSearch() [2/2]

FilterSearch::FilterSearch ( const FilterSearch &  )

private

Copying not allowed.

Member Function Documentation

copy()

SearchStrategy * FilterSearch::copy ( ) const

virtual

Returns a copy of this search strategy.

Client is responsible of deallocating the memory reserved for the returned object.

Returns

Copy of this search strategy.

Implements SearchStrategy.

Definition at line 80 of file FilterSearch.cc.

                         {
    
    CacheTable newEntryCache;
    for (CacheTable::const_iterator i = entryCache_.begin();
         i != entryCache_.end(); i++) {
        
        newEntryCache.push_back((*i)->copy());
    }
    FilterSearch* newSearch = new FilterSearch();
    newSearch->entryCache_ = newEntryCache;
    return newSearch;
}

References entryCache_, and FilterSearch().

Here is the call graph for this function:

createMatchers()

FilterSearch::MatcherTable FilterSearch::createMatchers ( const CostDBTypes::MatchTypeTable &  match )

private

Creates sub components of this search strategy.

Parameters

match

Type of match.

Returns

Sub components of this search strategy.

Exceptions

TypeMismatch

Requested type is unknown.

Definition at line 179 of file FilterSearch.cc.

                                                                   {
    MatcherTable matcher;
    for (CostDBTypes::MatchTypeTable::const_iterator i = match.begin();
         i != match.end(); i++) {
        
        Matcher* new_matcher = NULL;
        if ((*i)->matchingType() == CostDBTypes::MATCH_EXACT) {
            new_matcher = new ExactMatch((*i)->fieldType());
        } else if ((*i)->matchingType() == CostDBTypes::MATCH_SUBSET) {
            new_matcher = new SubSet((*i)->fieldType());
        } else if ((*i)->matchingType() == CostDBTypes::MATCH_SUPERSET) {
            new_matcher = new SuperSet((*i)->fieldType());
        } else if ((*i)->matchingType() == CostDBTypes::MATCH_INTERPOLATION) {
            new_matcher = new Interpolation((*i)->fieldType());
        } else if ((*i)->matchingType() == CostDBTypes::MATCH_ALL) {
            
        } else {
            throw TypeMismatch(__FILE__, __LINE__,
                               "FilterSearch::createMatchers");
        }
        
        assert(new_matcher != NULL);
        matcherStorage_.push_back(new_matcher);
        matcher.push_back(new_matcher);
    }
    return matcher;
}

References assert, CostDBTypes::MATCH_ALL, CostDBTypes::MATCH_EXACT, CostDBTypes::MATCH_INTERPOLATION, CostDBTypes::MATCH_SUBSET, CostDBTypes::MATCH_SUPERSET, and matcherStorage_.

Referenced by search().

findFromCache()

CostDBTypes::EntryTable FilterSearch::findFromCache ( const CostDBEntryKey &  searchKey, const CostDBTypes::MatchTypeTable &  match  )

private

Finds entries matching search key and type of match from the cache.

Parameters

searchKey	Search key.
match	Type of match.

Returns

Entries matching search key and type of match.

Definition at line 155 of file FilterSearch.cc.

                                            {
    
    CostDBTypes::EntryTable cacheEntries;
    for (CacheTable::iterator i = entryCache_.begin();
         i != entryCache_.end(); i++) {
        
        if ((*i)->isEqual(match, &searchKey)) {
            cacheEntries = (*i)->entries();
            break;
        }
    }
    return cacheEntries;
}

References entryCache_.

Referenced by search().

operator=()

FilterSearch& FilterSearch::operator= ( const FilterSearch &  )

private

Assignment not allowed.

search()

CostDBTypes::EntryTable FilterSearch::search ( const CostDBEntryKey &  searchKey, CostDBTypes::EntryTable  components, const CostDBTypes::MatchTypeTable &  match  )

virtual

Searches entries that match with certain search key on a specific type of match.

Search results are valid until the strategy is deleted, after which the use of the results of the queries might lead into unexpected behaviour.

Client must not deallocate the memory reserved for the results.

Parameters

searchKey	Search key.
components	Entries from which to find.
match	Type of match. The fields are searched in the order they exist in this table.

Returns

Entries matching search key and type of match.

Implements SearchStrategy.

Definition at line 110 of file FilterSearch.cc.

                                            {
    
    if (components.size() == 0) {
        return components;
    }
    
    // check the cache
    CostDBTypes::EntryTable cache_entries = findFromCache(searchKey, match);
    if (!cache_entries.empty()) {
        return cache_entries;
    }
    
    MatcherTable matcher = createMatchers(match);
    
    // filter quickly poor ones out
    for (MatcherTable::const_iterator i = matcher.begin();
         i != matcher.end(); i++) {
        
        (*i)->quickFilter(searchKey, components);
    }
    
    // choose correct entries from acceptable ones
    for (MatcherTable::const_iterator i = matcher.begin();
         i != matcher.end(); i++) {
        
        (*i)->filter(searchKey, components);
    }
    
    // insert found entries into cache
    entryCache_.push_back(new Cache(match, searchKey.copy(), components));
    
    return components;
}

References CostDBEntryKey::copy(), createMatchers(), entryCache_, and findFromCache().

Here is the call graph for this function:

Member Data Documentation

entryCache_

CacheTable FilterSearch::entryCache_

private

Results of the previous queries.

Definition at line 116 of file FilterSearch.hh.

Referenced by copy(), findFromCache(), search(), and ~FilterSearch().

matcherStorage_

MatcherTable FilterSearch::matcherStorage_

private

Storage for all matchers. They cannot be deleted before search strategy itself is deleted. Thus, this storage exists to deallocate the memory reserved by matchers.

Definition at line 120 of file FilterSearch.hh.

Referenced by createMatchers(), and ~FilterSearch().

---

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

• FilterSearch.hh
• FilterSearch.cc