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;
}
