bool TermRangeTermEnum::termCompare(TermPtr term)
{
if (!collator)
{
// Use Unicode code point ordering
bool checkLower = false;
if (!includeLower) // make adjustments to set to exclusive
checkLower = true;
if (term && term->field() == field)
{
if (!checkLower || VariantUtils::isNull(lowerTermText) || term->text().compare(VariantUtils::get<String>(lowerTermText)) > 0)
{
checkLower = false;
if (!VariantUtils::isNull(upperTermText))
{
int32_t compare = VariantUtils::get<String>(upperTermText).compare(term->text());
// if beyond the upper term, or is exclusive and this is equal to the upper term, break out
if (compare < 0 || (!includeUpper && compare == 0))
{
_endEnum = true;
return false;
}
}
return true;
}
}
else
{
// break
_endEnum = true;
return false;
}
return false;
}
else
{
if (term && term->field() == field)
{
if ((VariantUtils::isNull(lowerTermText) ||
(includeLower ? collator->compare(term->text(), VariantUtils::get<String>(lowerTermText)) >= 0 :
collator->compare(term->text(), VariantUtils::get<String>(lowerTermText)) > 0)) &&
(VariantUtils::isNull(upperTermText) ||
(includeUpper ? collator->compare(term->text(), VariantUtils::get<String>(upperTermText)) <= 0 :
collator->compare(term->text(), VariantUtils::get<String>(upperTermText)) < 0)))
return true;
return false;
}
_endEnum = true;
return false;
}
}
bool PrefixTermEnum::termCompare(TermPtr term)
{
if (term->field() == prefix->field() && boost::starts_with(term->text(), prefix->text()))
return true;
_endEnum = true;
return false;
}
PrefixTermEnum::PrefixTermEnum(IndexReaderPtr reader, TermPtr prefix)
{
this->_endEnum = false;
this->prefix = prefix;
setEnum(reader->terms(newLucene<Term>(prefix->field(), prefix->text())));
}
WildcardQuery::WildcardQuery(const TermPtr& term) {
this->term = term;
String text(term->text());
this->termContainsWildcard = boost::contains(text, L"*") || boost::contains(text, L"?");
this->termIsPrefix = termContainsWildcard &&
!boost::contains(text, L"?") &&
text.find_first_of(L"*") == text.length() - 1;
}
bool WildcardTermEnum::termCompare(const TermPtr& term) {
if (field == term->field()) {
String searchText(term->text());
if (boost::starts_with(searchText, pre)) {
return wildcardEquals(text, 0, searchText, preLen);
}
}
_endEnum = true;
return false;
}
void TermBuffer::set(TermPtr term)
{
if (!term)
{
reset();
return;
}
String termText(term->text());
int32_t termLen = termText.length();
text->setLength(termLen);
MiscUtils::arrayCopy(termText.begin(), 0, text->result.get(), 0, termLen);
field = term->field();
this->term = term;
}
void testEnumRange(int32_t lower, int32_t upper) {
NumericRangeQueryPtr q = NumericRangeQuery::newIntRange(L"field4", 4, lower, upper, true, true);
FilteredTermEnumPtr termEnum = newLucene<NumericRangeTermEnum>(q, searcher->getIndexReader());
do {
TermPtr t = termEnum->term();
if (t) {
int32_t val = NumericUtils::prefixCodedToInt(t->text());
EXPECT_TRUE(val >= lower && val <= upper);
} else {
break;
}
} while (termEnum->next());
EXPECT_TRUE(!termEnum->next());
termEnum->close();
}
void FuzzyQuery::ConstructQuery(const TermPtr& term, double minimumSimilarity, int32_t prefixLength) {
this->term = term;
if (minimumSimilarity >= 1.0) {
boost::throw_exception(IllegalArgumentException(L"minimumSimilarity >= 1"));
} else if (minimumSimilarity < 0.0) {
boost::throw_exception(IllegalArgumentException(L"minimumSimilarity < 0"));
}
if (prefixLength < 0) {
boost::throw_exception(IllegalArgumentException(L"prefixLength < 0"));
}
this->termLongEnough = ((int32_t)term->text().length() > (int32_t)(1.0 / (1.0 - minimumSimilarity)));
this->minimumSimilarity = minimumSimilarity;
this->prefixLength = prefixLength;
rewriteMethod = SCORING_BOOLEAN_QUERY_REWRITE();
}
bool NumericRangeTermEnum::termCompare(const TermPtr& term) {
return (term->field() == NumericRangeQueryPtr(_query)->field && term->text().compare(currentUpperBound) <= 0);
}
