bool PrefixTermEnum::termCompare(TermPtr term) { if (term->field() == prefix->field() && boost::starts_with(term->text(), prefix->text())) return true; _endEnum = true; return false; }
void QueryTermExtractor::getTerms(const Query* pQuery, WeightedTermsPtr& pWTs, bool prohibited, const string& fieldName) { if (!strCompare(pQuery->getIdentifier().c_str(), _T("BooleanQuery"))) { getTermsFromBooleanQuery((BooleanQuery*)pQuery, pWTs, prohibited, fieldName); } else { Query::TermVector terms; pQuery->terms(terms); TermPtr pTerm; for (size_t i = 0;i < terms.size(); i++) { pTerm = terms[i]; if ((fieldName.empty()) || (pTerm->getField() == fieldName)) { WeightedTermPtr pWT(new WeightedTerm(pQuery->getBoost(), pTerm.get())); pWTs->push_back(pWT); } else { WeightedTermPtr pWT(new WeightedTerm(pQuery->getBoost(), pTerm.get())); pWT->setField(fieldName); pWTs->push_back(pWT); } } } }
/// Deletes documents from an index that do not contain a term. int main(int argc, char* argv[]) { if (argc == 1) { std::wcout << L"Usage: deletefiles.exe <lucene index dir> <unique_term>\n"; return 1; } try { DirectoryPtr directory = FSDirectory::open(StringUtils::toUnicode(argv[1])); // we don't want read-only because we are about to delete IndexReaderPtr reader = IndexReader::open(directory, false); TermPtr term = newLucene<Term>(L"path", StringUtils::toUnicode(argv[2])); int32_t deleted = reader->deleteDocuments(term); std::wcout << L"Deleted " << deleted << L" documents containing " << term->toString() << L"\n"; reader->close(); directory->close(); } catch (LuceneException& e) { std::wcout << L"Exception: " << e.getError() << L"\n"; return 1; } return 0; }
PrefixTermEnum::PrefixTermEnum(IndexReaderPtr reader, TermPtr prefix) { this->_endEnum = false; this->prefix = prefix; setEnum(reader->terms(newLucene<Term>(prefix->field(), prefix->text()))); }
/** * @Inherit */ inline virtual void computeSymTransformation(SymbolPtr time) { //Get linked Bodies Body& root = Joint::getBodyRoot(); Body& leaf = Joint::getBodyLeaf(); //Get Joint structure const Vector2D& posRoot = Joint::getPosRoot(); const Vector2D& posLeaf = Joint::getPosLeaf(); scalar angleRoot = Joint::getAngleRoot(); scalar angleLeaf = Joint::getAngleLeaf(); //Build Joint structure Constants TermPtr angleRootSym = Constant::create(angleRoot); TermPtr angleLeafSym = Constant::create(angleLeaf); TermVectorPtr posRootSym = ConstantVector::create(posRoot); TermVectorPtr posLeafSym = ConstantVector::create(posLeaf); //Build unity vector TermVectorPtr unitySym = ConstantVector:: create(Vector2D(1.0, 0.0)); //Get Joint degree of freedom SymbolPtr dof = Joint::getDof(); //Sum up angle TermPtr angle1 = Symbolic::Add<scalar>::create( root.getSymAngle(), Symbolic::Add<scalar>::create( dof, angleRootSym)); //Build up Leaf Body orientation TermPtr resultAngle = Symbolic::Add<scalar>::create( angle1, Constant::create(-angleLeaf)); //Joint anchor on Root Body and Leaf Body TermVectorPtr p1 = Symbolic::Add<Vector2D>::create( root.getSymPosition(), Symbolic::Rotation<Vector2D, scalar>::create( posRootSym, root.getSymAngle())); //Build up center of Leaf Body TermVectorPtr resultPos = Symbolic::Add<Vector2D>::create( p1, Symbolic::Rotation<Vector2D, scalar>::create( Symbolic::Minus<Vector2D>::create(posLeafSym), resultAngle)); //Set up Leaf Symbols leaf.initSymbols( resultPos, resultAngle, resultPos->derivate(time), resultAngle->derivate(time)); }
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 PhraseQuery::add(TermPtr term, int32_t position) { if (terms.empty()) field = term->field(); else if (term->field() != field) boost::throw_exception(IllegalArgumentException(L"All phrase terms must be in the same field: " + term->toString())); terms.add(term); positions.add(position); if (position > maxPosition) maxPosition = position; }
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(); }
int64_t TermInfosReader::getPosition(TermPtr term) { if (_size == 0) return -1; ensureIndexIsRead(); int32_t indexOffset = getIndexOffset(term); SegmentTermEnumPtr enumerator(getThreadResources()->termEnum); seekEnum(enumerator, indexOffset); while (term->compareTo(enumerator->term()) > 0 && enumerator->next()) { } return term->compareTo(enumerator->term()) == 0 ? enumerator->position : -1; }
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 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; } }
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(); }
TermInfoPtr TermInfosReader::get(TermPtr term, bool useCache) { if (_size == 0) return TermInfoPtr(); ensureIndexIsRead(); TermInfoPtr ti; TermInfosReaderThreadResourcesPtr resources(getThreadResources()); TermInfoCachePtr cache; if (useCache) { cache = resources->termInfoCache; // check the cache first if the term was recently looked up ti = cache->get(term); if (ti) return ti; } // optimize sequential access: first try scanning cached enum without seeking SegmentTermEnumPtr enumerator = resources->termEnum; if (enumerator->term() && // term is at or past current ((enumerator->prev() && term->compareTo(enumerator->prev()) > 0) || term->compareTo(enumerator->term()) >= 0)) { int32_t enumOffset = (int32_t)(enumerator->position / totalIndexInterval ) + 1; if (indexTerms.size() == enumOffset || // but before end of block term->compareTo(indexTerms[enumOffset]) < 0) { // no need to seek int32_t numScans = enumerator->scanTo(term); if (enumerator->term() && term->compareTo(enumerator->term()) == 0) { ti = enumerator->termInfo(); if (cache && numScans > 1) { // we only want to put this TermInfo into the cache if scanEnum skipped more // than one dictionary entry. This prevents RangeQueries or WildcardQueries to // wipe out the cache when they iterate over a large numbers of terms in order. cache->put(term, ti); } } else ti.reset(); return ti; } } // random-access: must seek seekEnum(enumerator, getIndexOffset(term)); enumerator->scanTo(term); if (enumerator->term() && term->compareTo(enumerator->term()) == 0) { ti = enumerator->termInfo(); if (cache) cache->put(term, ti); } else ti.reset(); return ti; }
static bool parseLRS(ExpressionList* pList, N32 preparations, N32 measurements) { static char szRepresentation[] = "H-representation"; bool bFoundRepresentation = false; bool bBegin = false; char str[0x10000]; FILE* pF = fopen("lrs.hf", "r"); if (!pF) { errorExit("This program uses always uses lrs.hf as input which I couldn't find"); } while(fgets(str, sizeof(str), pF)) { #ifdef _PARSE_LOG ilog(""); #endif int nLen = strlen(str); char* p = str; if(str[nLen - 1] == '\n') str[nLen - 1] = 0; if (*p == '#' || *p == '*') continue; if (!bFoundRepresentation) { char* pPresentation = strstr(p, szRepresentation); if (pPresentation) bFoundRepresentation = true; continue; } if (!bBegin) { char* pBegin = strstr(p, "begin"); if (pBegin) bBegin = true; continue; } char* pEnd = strstr(p, "end"); if (pEnd) break; #ifdef _PARSE_LOG ilog(""); #endif N32 a[256]; for (int n = 0; n < 256; ++n) a[n] = 0; ExpressionPtr pIneq = new Expression(); pList->pushBack(pIneq); int dPlusOne = 0; while(true) { int ine; int rhs; N32 v = 0; if(!readBlks(p)) break; if (*p == 0) break; if (!readNumber2(p, v)) errorExit("error"); a[dPlusOne] = v; ++dPlusOne; } // in lrs the const is in LHS we need to change it to RHS pIneq->setRHS(a[0]); pIneq->setIne(-1); for (int i = 1; i < dPlusOne; ++i) { TermPtr p = new Term(); p->setState(a[i]); int n = i - 1; pIneq->set( n / measurements, n % measurements, p); #ifdef _PARSE_LOG log(" %dx%d", -a[n], n); #endif } } fclose(pF); return true; }
/** * @Inherit */ inline virtual void computeSymTransformation(SymbolPtr time) { //Get linked Bodies Body& root = Joint::getBodyRoot(); Body& leaf = Joint::getBodyLeaf(); //Get Joint structure const Vector2D& posRoot = Joint::getPosRoot(); const Vector2D& posLeaf = Joint::getPosLeaf(); scalar angleRoot = Joint::getAngleRoot(); scalar angleLeaf = Joint::getAngleLeaf(); //Build Joint structure Constants TermPtr angleRootSym = Constant::create(angleRoot); TermPtr angleLeafSym = Constant::create(angleLeaf); TermVectorPtr posRootSym = ConstantVector::create(posRoot); TermVectorPtr posLeafSym = ConstantVector::create(posLeaf); //Build unity vector TermVectorPtr unitySym = ConstantVector:: create(Vector2D(0.0, 1.0)); //Get Joint degree of freedom SymbolPtr dof = Joint::getDof(); //Sum up angle TermPtr angle1 = Symbolic::Add<scalar>::create( root.getSymAngle(), Symbolic::Add<scalar>::create( dof, angleRootSym)); TermPtr angle_root = Symbolic::Add<scalar>::create(root.getSymAngle(),angleRootSym); //Build up Leaf Body orientation // TermPtr resultAngle = Symbolic::Add<scalar>::create( // angle1, // Symbolic::Add<scalar>::create(Constant::create(-angleLeaf),_phi)); //Offset TermPtr resultAngle = Symbolic::Add<scalar>::create( angle1, Constant::create(-angleLeaf)); //Offset //Joint anchor on Root Body and Leaf Body TermVectorPtr p1 = Symbolic::Add<Vector2D>::create( root.getSymPosition(), Symbolic::Rotation<Vector2D, scalar>::create( posRootSym, root.getSymAngle())); TermPtr z=Symbolic::Add<scalar>::create(_F(Symbolic::Mult<scalar, scalar, scalar>::create(Symbolic::Minus<scalar>::create(_H),SIN(Symbolic::Add<scalar>::create(dof,_phi)))),Symbolic::Mult<scalar, scalar, scalar>::create(_H,COS(Symbolic::Add<scalar>::create(dof,_phi)))); _sl=z;//keep track of the translation for the spring //Joint anchor on Leaf Body // TermVectorPtr p2 = Symbolic::Add<Vector2D>::create( // p1, // Symbolic::Mult<Vector2D, scalar, Vector2D>::create( // z, // Symbolic::Rotation<Vector2D, scalar>::create( // unitySym, // angle_root))); TermVectorPtr p2 = Symbolic::Add<Vector2D>::create( p1, Symbolic::Mult<Vector2D, scalar, Vector2D>::create( z, Symbolic::Rotation<Vector2D, scalar>::create( unitySym, angle1))); //Build up center of Leaf Body TermVectorPtr resultPos = Symbolic::Add<Vector2D>::create( p2, Symbolic::Rotation<Vector2D, scalar>::create( Symbolic::Minus<Vector2D>::create(posLeafSym), resultAngle)); //Set up Leaf Symbols leaf.initSymbols( resultPos, // Symbolic::Add<scalar>::create(resultAngle,_phi), resultAngle, resultPos->derivate(time), resultAngle->derivate(time)); }
bool NumericRangeTermEnum::termCompare(const TermPtr& term) { return (term->field() == NumericRangeQueryPtr(_query)->field && term->text().compare(currentUpperBound) <= 0); }
bool parsePorta(ExpressionList* pList, N32 preparations, N32 measurements) { char str[0x10000]; FILE* pF = fopen("porta.poi.ieq", "r"); if (!pF) { errorExit("must have a porta.poi.ieq in the folder"); } int dim = 0; while(fgets(str, sizeof(str), pF)) { #ifdef _PARSE_LOG ilog(""); #endif int nLen = strlen(str); char* p = str; XK(str[nLen - 1] == '\n'); str[nLen - 1] = 0; char* pDim = strstr(p, "DIM = "); if (pDim) { pDim += 6; readNumber(pDim, dim); #ifdef _PARSE_LOG log("Dimension is %d:", dim); #endif continue; } if (!readChar(p, '(')) continue; int nVertex; if (!readNumber(p, nVertex)) errorExit("couldn't find a vertex number"); if (!readChar(p, ')')) continue; #ifdef _PARSE_LOG log("%d:", nVertex); #endif N32 a[256]; for (int n = 0; n < 256; ++n) a[n] = 0; ExpressionPtr pIneq = new Expression(); pList->pushBack(pIneq); int varIndexMax = -1; while(true) { int sign; int ine; int rhs; if(!readBlks(p)) errorExit("incomplet"); if (readIne(p, ine)) { if (!readNumber(p, rhs)) errorExit("couldn't find lrs"); #ifdef _PARSE_LOG log(" rhs: %d .... %s", rhs, str); #endif pIneq->setRHS(rhs); pIneq->setIne(ine); pIneq->setPortaExp(str); break; } if (!readSign(p, sign)) errorExit("couldn't find a sign (+/-)"); int factor = 1; readNumber(p, factor); if (!readChar(p, 'x')) errorExit("couldn't find a x"); int varIndex; if (!readNumber(p, varIndex)) errorExit("couldn't find a >"); if (varIndex > varIndexMax) varIndexMax = varIndex; N32 termState = (sign == '-') ? -factor : factor; //fprintf(pLog, " %dx%d", termState, varIndex); //TermPtr p = new Term(); //p->setState(termState); //pIneq->pushBack(p); a[varIndex - 1] = termState; } for (int n = 0; n < dim; ++n) { TermPtr p = new Term(); p->setState(a[n]); pIneq->set(n / measurements, n % measurements, p); #ifdef _PARSE_LOG log(" %dx%d", a[n], n); #endif } } fclose(pF); return true; }