RangeQuery::RangeQuery(Term* lowerTerm, Term* upperTerm, const bool Inclusive){
//Func - Constructor
//Pre - (LowerTerm != NULL OR UpperTerm != NULL) AND
// if LowerTerm and UpperTerm are valid pointer then the fieldnames must be the same
//Post - The instance has been created
if (lowerTerm == NULL && upperTerm == NULL)
{
_CLTHROWA(CL_ERR_IllegalArgument,"At least one term must be non-null");
}
if (lowerTerm != NULL && upperTerm != NULL && lowerTerm->field() != upperTerm->field())
{
_CLTHROWA(CL_ERR_IllegalArgument,"Both terms must be for the same field");
}
// if we have a lowerTerm, start there. otherwise, start at beginning
if (lowerTerm != NULL) {
this->lowerTerm = _CL_POINTER(lowerTerm);
}
else {
this->lowerTerm = _CLNEW Term(upperTerm, LUCENE_BLANK_STRING);
}
this->upperTerm = (upperTerm != NULL ? _CL_POINTER(upperTerm) : NULL);
this->inclusive = Inclusive;
}
/** IndexInput methods */
void FSDirectory::FSIndexInput::readInternal(uint8_t* b, const int32_t len) {
SCOPED_LOCK_MUTEX(handle->THIS_LOCK)
CND_PRECONDITION(handle!=NULL,"shared file handle has closed");
CND_PRECONDITION(handle->fhandle>=0,"file is not open");
if ( handle->_fpos != _pos ){
if ( fileSeek(handle->fhandle,_pos,SEEK_SET) != _pos ){
_CLTHROWA( CL_ERR_IO, "File IO Seek error");
}
handle->_fpos = _pos;
}
bufferLength = _read(handle->fhandle,b,len); // 2004.10.31:SF 1037836
if (bufferLength == 0){
_CLTHROWA(CL_ERR_IO, "read past EOF");
}
if (bufferLength == -1){
//if (EINTR == errno) we could do something else... but we have
//to guarantee some return, or throw EOF
_CLTHROWA(CL_ERR_IO, "read error");
}
_pos+=bufferLength;
handle->_fpos=_pos;
}
void DateField::timeToString(const int64_t time, TCHAR* buf) {
CND_PRECONDITION (buf, "buf == NULL");
*buf = '\0';
if (time < 0)
_CLTHROWA (CL_ERR_IllegalArgument,"time too early"); //todo: make richer error
if (time > DATEFIELD_DATE_MAX)
_CLTHROWA (CL_ERR_IllegalArgument, "time too late (past DATEFIELD_DATE_MAX"); //todo: make richer error
_i64tot(time, buf, 36);
int32_t bufLen = _tcslen(buf);
CND_PRECONDITION (bufLen <= DATEFIELD_DATE_LEN, "timeToString length is greater than 9");
/* Supply leading zeroes if necessary. */
if (bufLen < DATEFIELD_DATE_LEN) {
const int32_t nMissingZeroes = DATEFIELD_DATE_LEN - bufLen;
/* Move buffer contents forward to make room for leading zeroes. */
for (int32_t i = DATEFIELD_DATE_LEN - 1; i >= nMissingZeroes; i--)
buf[i] = buf[i - nMissingZeroes];
/* Insert leading zeroes. */
{// MSVC6 scoping fix
for (int32_t i = 0; i < nMissingZeroes; i++)
buf[i] = '0';
}
buf[DATEFIELD_DATE_LEN] = 0;
}
CND_PRECONDITION (_tcslen(buf) == DATEFIELD_DATE_LEN, "timeToString return is not equal to DATEFIELD_DATE_LEN");
}
FSDirectory::FSIndexInput::FSIndexInput(const char* path, int32_t __bufferSize):
BufferedIndexInput(__bufferSize)
{
//Func - Constructor.
// Opens the file named path
//Pre - path != NULL
//Post - if the file could not be opened an exception is thrown.
CND_PRECONDITION(path != NULL, "path is NULL");
handle = _CLNEW SharedHandle();
strcpy(handle->path,path);
//Open the file
handle->fhandle = _open(path, O_BINARY | O_RDONLY | O_RANDOM, _S_IREAD );
//Check if a valid handle was retrieved
if (handle->fhandle < 0){
int err = errno;
if ( err == ENOENT )
_CLTHROWA(CL_ERR_IO, "File does not exist");
else if ( err == EACCES )
_CLTHROWA(CL_ERR_IO, "File Access denied");
else if ( err == EMFILE )
_CLTHROWA(CL_ERR_IO, "Too many open files");
}
//Store the file length
handle->_length = fileSize(handle->fhandle);
handle->_fpos = 0;
this->_pos = 0;
}
FuzzyTermEnum::FuzzyTermEnum(IndexReader* reader, Term* term, float_t minSimilarity, size_t _prefixLength):
FilteredTermEnum(),d(NULL),dLen(0),_similarity(0),_endEnum(false),searchTerm(_CL_POINTER(term)),
text(NULL),textLen(0),prefix(NULL)/* ISH: was STRDUP_TtoT(LUCENE_BLANK_STRING)*/,prefixLength(0),
minimumSimilarity(minSimilarity)
{
CND_PRECONDITION(term != NULL,"term is NULL");
if (minSimilarity >= 1.0f)
_CLTHROWA(CL_ERR_IllegalArgument,"minimumSimilarity cannot be greater than or equal to 1");
else if (minSimilarity < 0.0f)
_CLTHROWA(CL_ERR_IllegalArgument,"minimumSimilarity cannot be less than 0");
scale_factor = 1.0f / (1.0f - minimumSimilarity); // only now we are safe from a division by zero
//TODO: this.field = searchTerm.field();
//The prefix could be longer than the word.
//It's kind of silly though. It means we must match the entire word.
const size_t fullSearchTermLength = searchTerm->textLength();
const size_t realPrefixLength = _prefixLength > fullSearchTermLength ? fullSearchTermLength : _prefixLength;
text = STRDUP_TtoT(searchTerm->text() + realPrefixLength);
textLen = fullSearchTermLength - realPrefixLength;
prefix = _CL_NEWARRAY(TCHAR,realPrefixLength+1);
_tcsncpy(prefix, searchTerm->text(), realPrefixLength);
prefix[realPrefixLength]='\0';
prefixLength = realPrefixLength;
initializeMaxDistances();
Term* trm = _CLNEW Term(searchTerm->field(), prefix); // _CLNEW Term(term, prefix); -- not intern'd?
setEnum(reader->terms(trm));
_CLLDECDELETE(trm);
/* LEGACY:
//Initialize e to NULL
e = NULL;
eWidth = 0;
eHeight = 0;
if(prefixLength > 0 && prefixLength < textLen){
this->prefixLength = prefixLength;
prefix = _CL_NEWARRAY(TCHAR,prefixLength+1);
_tcsncpy(prefix,text,prefixLength);
prefix[prefixLength]='\0';
textLen = prefixLength;
text[textLen]='\0';
}
*/
}
MMapIndexInput::MMapIndexInput(const char* path):
_internal(_CLNEW Internal)
{
//Func - Constructor.
// Opens the file named path
//Pre - path != NULL
//Post - if the file could not be opened an exception is thrown.
CND_PRECONDITION(path != NULL, "path is NULL");
#if defined(_CL_HAVE_FUNCTION_MAPVIEWOFFILE)
_internal->mmaphandle = NULL;
_internal->fhandle = CreateFileA(path,GENERIC_READ,FILE_SHARE_READ, 0,OPEN_EXISTING,0,0);
//Check if a valid fhandle was retrieved
if (_internal->fhandle < 0){
_cl_dword_t err = GetLastError();
if ( err == ERROR_FILE_NOT_FOUND )
_CLTHROWA(CL_ERR_IO, "File does not exist");
else if ( err == ERROR_ACCESS_DENIED )
_CLTHROWA(ERROR_ACCESS_DENIED, "File Access denied");
else if ( err == ERROR_TOO_MANY_OPEN_FILES )
_CLTHROWA(CL_ERR_IO, "Too many open files");
else
_CLTHROWA(CL_ERR_IO, "File IO Error");
}
_cl_dword_t dummy=0;
_internal->_length = GetFileSize(_internal->fhandle, &dummy);
if ( _internal->_length > 0 ){
_internal->mmaphandle = CreateFileMappingA(_internal->fhandle,NULL,PAGE_READONLY,0,0,NULL);
if ( _internal->mmaphandle != NULL ){
void* address = MapViewOfFile(_internal->mmaphandle,FILE_MAP_READ,0,0,0);
if ( address != NULL ){
_internal->data = (uint8_t*)address;
return; //SUCCESS!
}
}
//failure:
int errnum = GetLastError();
CloseHandle(_internal->mmaphandle);
char* lpMsgBuf=strerror(errnum);
size_t len = strlen(lpMsgBuf)+80;
char* errstr = _CL_NEWARRAY(char, len);
cl_sprintf(errstr, "MMapIndexInput::MMapIndexInput failed with error %d: %s", len, errnum, lpMsgBuf);
_CLTHROWA_DEL(CL_ERR_IO,errstr);
}
FuzzyQuery::FuzzyQuery(Term* term, float_t _minimumSimilarity, size_t _prefixLength):
MultiTermQuery(term),
minimumSimilarity(_minimumSimilarity),
prefixLength(_prefixLength)
{
if ( minimumSimilarity < 0 )
minimumSimilarity = defaultMinSimilarity;
CND_PRECONDITION(term != NULL,"term is NULL");
if (minimumSimilarity >= 1.0f)
_CLTHROWA(CL_ERR_IllegalArgument,"minimumSimilarity >= 1");
else if (minimumSimilarity < 0.0f)
_CLTHROWA(CL_ERR_IllegalArgument,"minimumSimilarity < 0");
}
ScoreDocComparatorImpl(FieldCacheAuto* fca){
this->fca = fca;
if ( fca->contentType != FieldCacheAuto::COMPARABLE_ARRAY )
_CLTHROWA(CL_ERR_InvalidCast,"Invalid field cache auto type");
this->cachedValues = fca->comparableArray;
this->cachedValuesLen = fca->contentLen;
}
void TransactionalRAMDirectory::transCommit() {
if (!transOpen) {
_CLTHROWA(CL_ERR_RAMTransaction,"There is no open transaction.");
}
// All storage is in memory, so commit is ultra-simple.
transResolved();
}
void TransactionalRAMDirectory::transAbort()
{
if (!transOpen)
_CLTHROWA(CL_ERR_RAMTransaction, "There is no open transaction.");
// Delete each file in filesToRemoveOnAbort.
FilenameSet::const_iterator itrDel = filesToRemoveOnAbort.begin();
for ( ; itrDel != filesToRemoveOnAbort.end(); ++itrDel) {
size_t nameLength = itrDel->first.length();
// Special exception: Refrain from deleting a lock's flag file, as that
// would interfere with the operation of the lock.
if (!(nameLength >= 5
&& itrDel->first.rightRef(5) == QLatin1String(".lock"))) {
RAMDirectory::deleteFile(itrDel->first);
}
}
// Ownership of the memory of both the key and the value never left files,
// so there's no need for a special directive to filesToRemoveOnAbort.
filesToRemoveOnAbort.clear();
// Now that any new-since-trans-start files with the same names as
// already-present-at-trans-start files are out of the way, restore each
// file in filesToRestoreOnAbort.
TransFileMap::const_iterator itr = filesToRestoreOnAbort.begin();
for ( ; itr != filesToRestoreOnAbort.end(); ++itr) {
files.put(itr->first, itr->second);
filesToRestoreOnAbort.remove(itr->first);
}
CND_CONDITION(filesToRestoreOnAbort.size() == 0,
"filesToRestoreOnAbort should be empty.");
transResolved();
}
void FastCharStream::refill() {
int32_t newPosition = bufferLength - tokenStart;
if (tokenStart == 0) { // token won't fit in buffer
if (buffer == NULL) { // first time: alloc buffer
buffer = _CL_NEWARRAY(TCHAR, 2048);
_bufferSize = 2048;
} else if (bufferLength == _bufferSize) { // grow buffer
_bufferSize *= 2;
TCHAR* newBuffer = _CL_NEWARRAY(TCHAR, _bufferSize);
_tcsncpy(newBuffer, buffer, bufferLength);
_CLDELETE_LCARRAY(buffer);
buffer = newBuffer;
}
} else { // shift token to front
_tcsncpy(buffer, buffer+tokenStart,newPosition);
}
bufferLength = newPosition; // update state
bufferPosition = newPosition;
bufferStart += tokenStart;
tokenStart = 0;
const TCHAR* charBuf = NULL;
int32_t charsRead = // fill space in buffer
input->read(charBuf, newPosition, _bufferSize-newPosition);
if (charsRead == -1){
_CLTHROWA(CL_ERR_IO, "read past eof");
}
else {
memcpy(buffer, charBuf, charsRead * sizeof(TCHAR)); // TODO: Can we use the reader buffer instead of copying to our own?
bufferLength += charsRead;
}
}
/**
* Writer calls this when it has hit an error and had to
* roll back, to tell us that there may now be
* unreferenced files in the filesystem. So we re-list
* the filesystem and delete such files. If segmentName
* is non-NULL, we will only delete files corresponding to
* that segment.
*/
void IndexFileDeleter::refresh(const char* segmentName) {
vector<string> files;
if ( !directory->list(files) )
_CLTHROWA(CL_ERR_IO, (string("cannot read directory ") + directory->toString() + ": list() returned NULL").c_str() );
const IndexFileNameFilter* filter = IndexFileNameFilter::getFilter();
string segmentPrefix1;
string segmentPrefix2;
if (segmentName != NULL) {
segmentPrefix1 = string(segmentName) + ".";
segmentPrefix2 = string(segmentName) + "_";
}
for(size_t i=0;i<files.size();i++) {
string& fileName = files[i];
if ( filter->accept(NULL, fileName.c_str()) &&
( (segmentName==NULL || fileName.compare(0,segmentPrefix1.length(),segmentPrefix1) == 0 || fileName.compare(0,segmentPrefix2.length(),segmentPrefix2)==0)
&& refCounts.find((char*)fileName.c_str())== refCounts.end() && fileName.compare(IndexFileNames::SEGMENTS_GEN)!=0) ){
// Unreferenced file, so remove it
if (infoStream != NULL) {
message( string("refresh [prefix=") + segmentName + "]: removing newly created unreferenced file \"" + fileName + "\"");
}
deleteFile(fileName.c_str());
}
}
}
Field::Field(const TCHAR* Name, Reader* reader, bool store, bool index, bool token, const bool storeTermVector)
{
//Func - Constructor
//Pre - Name != NULL and contains the name of the field
// reader != NULL and contains a Reader
// store indicates if the field must be stored
// index indicates if the field must be indexed
// token indicates if the field must be tokenized
//Post - The instance has been created
CND_PRECONDITION(Name != NULL, "Name is NULL");
CND_PRECONDITION(reader != NULL, "reader is NULL");
_name = LStringIntern::intern( Name CL_FILELINE);
_stringValue = NULL;
_readerValue = reader;
_streamValue = NULL;
boost=1.0f;
omitNorms = false;
int cfg = 0;
if ( store )
cfg |= STORE_YES;
if ( index && token )
cfg |= INDEX_TOKENIZED;
else if ( index && !token )
cfg |= INDEX_UNTOKENIZED;
if ( storeTermVector )
_CLTHROWA(CL_ERR_IllegalArgument,"Stored term vector is deprecated with using this constructor");
setConfig(cfg);
}
//todo: Locale locale, not implemented yet
ScoreDocComparator* FieldSortedHitQueue::getCachedComparator (IndexReader* reader, const TCHAR* fieldname, int32_t type, SortComparatorSource* factory){
if (type == SortField::DOC)
return ScoreDocComparator::INDEXORDER;
if (type == SortField::DOCSCORE)
return ScoreDocComparator::RELEVANCE;
ScoreDocComparator* comparator = lookup (reader, fieldname, type, factory);
if (comparator == NULL) {
switch (type) {
case SortField::AUTO:
comparator = comparatorAuto (reader, fieldname);
break;
case SortField::INT:
comparator = comparatorInt (reader, fieldname);
break;
case SortField::FLOAT:
comparator = comparatorFloat (reader, fieldname);
break;
case SortField::STRING:
//if (locale != NULL)
// comparator = comparatorStringLocale (reader, fieldname, locale);
//else
comparator = comparatorString (reader, fieldname);
break;
case SortField::CUSTOM:
comparator = factory->newComparator (reader, fieldname);
break;
default:
_CLTHROWA(CL_ERR_Runtime,"unknown field type");
//todo: extend error
//throw _CLNEW RuntimeException ("unknown field type: "+type);
}
store (reader, fieldname, type, factory, comparator);
}
return comparator;
}
int64_t Reader::mark(int32_t readAheadlimit) {
int64_t pos = reader->mark(readAheadlimit);
if (pos < 0) {
_CLTHROWA(CL_ERR_IO, reader->getError());
}
else
return pos;
}
int64_t Reader::skip(int64_t ntoskip) {
int64_t skipped = reader->skip(ntoskip);
if (skipped < 0) {
_CLTHROWA(CL_ERR_IO, reader->getError());
}
else
return skipped;
}
int32_t Reader::read(const UChar*& start, int32_t len) {
int32_t nread = reader->read(start, len, len);
if (nread < -1) { //if not eof
_CLTHROWA(CL_ERR_IO, reader->getError());
}
else
return nread;
}
CL_NS(store)::Directory* IndexReader::directory() {
ensureOpen();
if (NULL != _internal->directory) {
return _internal->directory;
} else {
_CLTHROWA(CL_ERR_UnsupportedOperation, "This reader does not support this method.");
}
}
FSDirectory::FSIndexInput::SharedHandle::~SharedHandle() throw(CLuceneError&){
if ( fhandle >= 0 ){
if ( _close(fhandle) != 0 )
_CLTHROWA(CL_ERR_IO, "File IO Close error");
else
fhandle = -1;
}
}
void FSDirectory::FSIndexOutput::seek(const int64_t pos) {
CND_PRECONDITION(fhandle>=0,"file is not open");
BufferedIndexOutput::seek(pos);
int64_t ret = fileSeek(fhandle,pos,SEEK_SET);
if ( ret != pos ){
_CLTHROWA(CL_ERR_IO, "File IO Seek error");
}
}
int64_t Reader::reset(int64_t pos) {
int64_t r = reader->reset(pos);
if (r < 0) {
_CLTHROWA(CL_ERR_IO, reader->getError());
}
else
return r;
}
int32_t Compare::TChar::compareTo(void* o){
try{
TChar* os = (TChar*)o;
return _tcscmp(s,os->s);
}catch(...){
_CLTHROWA(CL_ERR_Runtime,"Couldnt compare types");
}
}
void TransactionalRAMDirectory::unarchiveOrigFile(const char* name) {
const char* origName = filesToRestoreOnAbort.getKey(name);
if (origName == NULL) {
_CLTHROWA(CL_ERR_RAMTransaction,"File submitted for unarchival was not archived.");
}
RAMFile* origFile = filesToRestoreOnAbort.get(name);
// Transfer memory ownership back to files from filesToRestoreOnAbort.
filesToRestoreOnAbort.remove(name, true, true);
files.put(origName, origFile);
}
bool LuceneLock::obtain(int64_t lockWaitTimeout) {
bool locked = obtain();
if ( lockWaitTimeout < 0 && lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER ) {
_CLTHROWA(CL_ERR_IllegalArgument,"lockWaitTimeout should be LOCK_OBTAIN_WAIT_FOREVER or a non-negative number");
}
int64_t maxSleepCount = lockWaitTimeout / LOCK_POLL_INTERVAL;
int64_t sleepCount = 0;
while (!locked) {
if ( lockWaitTimeout != LOCK_OBTAIN_WAIT_FOREVER && sleepCount++ == maxSleepCount ) {
_CLTHROWA(CL_ERR_IO,"Lock obtain timed out");
}
_LUCENE_SLEEP(LOCK_POLL_INTERVAL);
locked = obtain();
}
return locked;
}
int Reader::read() {
const UChar*b;
int32_t nread = reader->read(b, 1, 1);
if (nread < -1) { //if not eof
_CLTHROWA(CL_ERR_IO, reader->getError());
}
else if (nread == -1)
return -1;
else
return b[0];
}
void TransactionalRAMDirectory::transAbort() {
if (!transOpen) {
_CLTHROWA(CL_ERR_RAMTransaction,"There is no open transaction.");
}
// Delete each file in filesToRemoveOnAbort.
for (FilenameSet::const_iterator itrDel = filesToRemoveOnAbort.begin();
itrDel != filesToRemoveOnAbort.end();
++itrDel
)
{
const char* name = itrDel->first;
size_t nameLength = strlen(name);
// Special exception:
// Refrain from deleting a lock's flag file, as that would interfere with
// the operation of the lock.
if (!(nameLength >= 5 && strcmp(name + nameLength - 5, ".lock"))) {
RAMDirectory::deleteFile(name);
}
}
// Ownership of the memory of both the key and the value never left files,
// so there's no need for a special directive to filesToRemoveOnAbort.
filesToRemoveOnAbort.clear();
// Now that any new-since-trans-start files with the same names as
// already-present-at-trans-start files are out of the way, restore each
// file in filesToRestoreOnAbort.
AStringArrayConst removeTheseWithoutDeletingMem;
for (TransFileMap::const_iterator itr = filesToRestoreOnAbort.begin();
itr != filesToRestoreOnAbort.end();
++itr
)
{
const char* name = itr->first;
files.put(name, itr->second);
// We've just transferred ownership of the memory of both the key and the
// value to files; we must now direct filesToRestoreOnAbort not to delete
// that memory as it removes the entry. This is performed in a separate
// loop to avoid modifying filesToRestoreOnAbort while iterating over it.
removeTheseWithoutDeletingMem.push_back(name);
}
for (AStringArrayConst::iterator itrRem = removeTheseWithoutDeletingMem.begin();
itrRem != removeTheseWithoutDeletingMem.end();
++itrRem
)
{
filesToRestoreOnAbort.remove(*itrRem); //remove iterator
}
CND_CONDITION(filesToRestoreOnAbort.size() == 0, "filesToRestoreOnAbort should be empty.");
transResolved();
}
int32_t Compare::Float::compareTo(void* o){
try{
Float* other = (Float*)o;
if (value == other->value)
return 0;
// Returns just -1 or 1 on inequality; doing math might overflow.
return value > other->value ? 1 : -1;
}catch(...){
_CLTHROWA(CL_ERR_Runtime,"Couldnt compare types");
}
}
FSDirectory::FSIndexOutput::FSIndexOutput(const char* path){
//O_BINARY - Opens file in binary (untranslated) mode
//O_CREAT - Creates and opens new file for writing. Has no effect if file specified by filename exists
//O_RANDOM - Specifies that caching is optimized for, but not restricted to, random access from disk.
//O_WRONLY - Opens file for writing only;
if ( Misc::dir_Exists(path) )
fhandle = _open( path, O_BINARY | O_RDWR | O_RANDOM | O_TRUNC, _S_IREAD | _S_IWRITE);
else // added by JBP
fhandle = _open( path, O_BINARY | O_RDWR | O_RANDOM | O_CREAT, _S_IREAD | _S_IWRITE);
if ( fhandle < 0 ){
int err = errno;
if ( err == ENOENT )
_CLTHROWA(CL_ERR_IO, "File does not exist");
else if ( err == EACCES )
_CLTHROWA(CL_ERR_IO, "File Access denied");
else if ( err == EMFILE )
_CLTHROWA(CL_ERR_IO, "Too many open files");
}
}
void FastCharStream::UnGet(){
// printf("UnGet \n");
if (input == 0)
return;
if ( pos == 0 ) {
_CLTHROWA(CL_ERR_IO,"error : No character can be UnGet");
}
rewindPos++;
input->reset(pos-1);
pos--;
}
FSDirectory::FSIndexInput::FSIndexInput(const FSIndexInput& other): BufferedIndexInput(other){
//Func - Constructor
// Uses clone for its initialization
//Pre - clone is a valide instance of FSIndexInput
//Post - The instance has been created and initialized by clone
if ( other.handle == NULL )
_CLTHROWA(CL_ERR_NullPointer, "other handle is null");
SCOPED_LOCK_MUTEX(other.handle->THIS_LOCK)
handle = _CL_POINTER(other.handle);
_pos = other.handle->_fpos; //note where we are currently...
}
