blob: 9373cef0a558c0a43d1e4364545a1d044c6e2932 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/*------------------------------------------------------------------------------
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
*
* Distributable under the terms of either the Apache License (Version 2.0) or
* the GNU Lesser General Public License, as specified in the COPYING file.
------------------------------------------------------------------------------*/
#include "CLucene/StdHeader.h"
#include "WildcardQuery.h"
#include "CLucene/util/BitSet.h"
CL_NS_USE(index)
CL_NS_USE(util)
CL_NS_DEF(search)
WildcardQuery::WildcardQuery(Term* term):
MultiTermQuery( term ){
//Func - Constructor
//Pre - term != NULL
//Post - Instance has been created
}
WildcardQuery::~WildcardQuery(){
//Func - Destructor
//Pre - true
//Post - true
}
const TCHAR* WildcardQuery::getQueryName() const{
//Func - Returns the string "WildcardQuery"
//Pre - true
//Post - The string "WildcardQuery" has been returned
return getClassName();
}
const TCHAR* WildcardQuery::getClassName(){
return _T("WildcardQuery");
}
FilteredTermEnum* WildcardQuery::getEnum(IndexReader* reader) {
return _CLNEW WildcardTermEnum(reader, getTerm(false));
}
WildcardQuery::WildcardQuery(const WildcardQuery& clone):
MultiTermQuery(clone)
{
}
Query* WildcardQuery::clone() const{
return _CLNEW WildcardQuery(*this);
}
size_t WildcardQuery::hashCode() const{
//todo: we should give the query a seeding value... but
//need to do it for all hascode functions
return Similarity::floatToByte(getBoost()) ^ getTerm()->hashCode();
}
bool WildcardQuery::equals(Query* other) const{
if (!(other->instanceOf(WildcardQuery::getClassName())))
return false;
WildcardQuery* tq = (WildcardQuery*)other;
return (this->getBoost() == tq->getBoost())
&& getTerm()->equals(tq->getTerm());
}
WildcardFilter::WildcardFilter( Term* term )
{
this->term = _CL_POINTER(term);
}
WildcardFilter::~WildcardFilter()
{
_CLDECDELETE(term);
}
WildcardFilter::WildcardFilter( const WildcardFilter& copy ) :
term( _CL_POINTER(copy.term) )
{
}
Filter* WildcardFilter::clone() const {
return _CLNEW WildcardFilter(*this );
}
TCHAR* WildcardFilter::toString()
{
//Instantiate a stringbuffer buffer to store the readable version temporarily
CL_NS(util)::StringBuffer buffer;
//check if field equal to the field of prefix
if( term->field() != NULL ) {
//Append the field of prefix to the buffer
buffer.append(term->field());
//Append a colon
buffer.append(_T(":") );
}
//Append the text of the prefix
buffer.append(term->text());
//Convert StringBuffer buffer to TCHAR block and return it
return buffer.toString();
}
/** Returns a BitSet with true for documents which should be permitted in
search results, and false for those that should not. */
BitSet* WildcardFilter::bits( IndexReader* reader )
{
BitSet* bts = _CLNEW BitSet( reader->maxDoc() );
WildcardTermEnum termEnum (reader, term);
if (termEnum.term(false) == NULL)
return bts;
TermDocs* termDocs = reader->termDocs();
try{
do{
termDocs->seek(&termEnum);
while (termDocs->next()) {
bts->set(termDocs->doc());
}
}while(termEnum.next());
} _CLFINALLY(
termDocs->close();
_CLDELETE(termDocs);
termEnum.close();
)
return bts;
}
CL_NS_END
|
