| /**************************************************************************** |
| ** |
| ** Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team. |
| ** All rights reserved. |
| ** |
| ** Portion Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this file. |
| ** Please review the following information to ensure the GNU Lesser General |
| ** Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ****************************************************************************/ |
| |
| #include "qindexwriter_p.h" |
| #include "qindexreader_p.h" |
| |
| #include <CLucene.h> |
| #include <CLucene/index/IndexWriter.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| QCLuceneIndexWriterPrivate::QCLuceneIndexWriterPrivate() |
| : QSharedData() |
| { |
| writer = 0; |
| deleteCLuceneIndexWriter = true; |
| } |
| |
| QCLuceneIndexWriterPrivate::QCLuceneIndexWriterPrivate(const QCLuceneIndexWriterPrivate &other) |
| : QSharedData() |
| { |
| writer = _CL_POINTER(other.writer); |
| deleteCLuceneIndexWriter = other.deleteCLuceneIndexWriter; |
| } |
| |
| QCLuceneIndexWriterPrivate::~QCLuceneIndexWriterPrivate() |
| { |
| if (deleteCLuceneIndexWriter) |
| _CLDECDELETE(writer); |
| } |
| |
| |
| QCLuceneIndexWriter::QCLuceneIndexWriter(const QString &path, |
| QCLuceneAnalyzer &analyzer, |
| bool create, bool closeDir) |
| : d(new QCLuceneIndexWriterPrivate()) |
| , analyzer(analyzer) |
| { |
| d->writer = new lucene::index::IndexWriter(path, |
| analyzer.d->analyzer, create, closeDir); |
| } |
| |
| QCLuceneIndexWriter::~QCLuceneIndexWriter() |
| { |
| // nothing todo |
| } |
| |
| void QCLuceneIndexWriter::close() |
| { |
| d->writer->close(); |
| } |
| |
| void QCLuceneIndexWriter::optimize() |
| { |
| d->writer->optimize(); |
| } |
| |
| qint32 QCLuceneIndexWriter::docCount() |
| { |
| return qint32(d->writer->docCount()); |
| } |
| |
| QCLuceneAnalyzer QCLuceneIndexWriter::getAnalyzer() |
| { |
| return analyzer; |
| } |
| |
| void QCLuceneIndexWriter::addIndexes(const QList<QCLuceneIndexReader*> &readers) |
| { |
| using namespace lucene::index; |
| IndexReader** readerArray = new IndexReader*[readers.count()]; |
| |
| for (int i = 0; i < readers.count(); ++i) |
| readerArray[i] = (readers.at(i))->d->reader; |
| |
| d->writer->addIndexes(readerArray); |
| delete [] readerArray; |
| } |
| |
| void QCLuceneIndexWriter::addDocument(QCLuceneDocument &doc, |
| QCLuceneAnalyzer &analyzer) |
| { |
| if (doc.d->document) |
| d->writer->addDocument(doc.d->document, analyzer.d->analyzer); |
| } |
| |
| qint32 QCLuceneIndexWriter::getMaxFieldLength() const |
| { |
| return qint32(d->writer->getMaxFieldLength()); |
| } |
| |
| void QCLuceneIndexWriter::setMaxFieldLength(qint32 value) |
| { |
| d->writer->setMaxFieldLength(int32_t(value)); |
| } |
| |
| qint32 QCLuceneIndexWriter::getMaxBufferedDocs() const |
| { |
| return qint32(d->writer->getMaxBufferedDocs()); |
| } |
| |
| void QCLuceneIndexWriter::setMaxBufferedDocs(qint32 value) |
| { |
| d->writer->setMaxBufferedDocs(int32_t(value)); |
| } |
| |
| qint64 QCLuceneIndexWriter::getWriteLockTimeout() const |
| { |
| return qint64(d->writer->getWriteLockTimeout()); |
| } |
| |
| void QCLuceneIndexWriter::setWriteLockTimeout(qint64 writeLockTimeout) |
| { |
| d->writer->setWriteLockTimeout(int64_t(writeLockTimeout)); |
| } |
| |
| qint64 QCLuceneIndexWriter::getCommitLockTimeout() const |
| { |
| return qint64(d->writer->getCommitLockTimeout()); |
| } |
| |
| void QCLuceneIndexWriter::setCommitLockTimeout(qint64 commitLockTimeout) |
| { |
| d->writer->setCommitLockTimeout(int64_t(commitLockTimeout)); |
| } |
| |
| qint32 QCLuceneIndexWriter::getMergeFactor() const |
| { |
| return qint32(d->writer->getMergeFactor()); |
| } |
| |
| void QCLuceneIndexWriter::setMergeFactor(qint32 value) |
| { |
| d->writer->setMergeFactor(int32_t(value)); |
| } |
| |
| qint32 QCLuceneIndexWriter::getTermIndexInterval() const |
| { |
| return qint32(d->writer->getTermIndexInterval()); |
| } |
| |
| void QCLuceneIndexWriter::setTermIndexInterval(qint32 interval) |
| { |
| d->writer->setTermIndexInterval(int32_t(interval)); |
| } |
| |
| qint32 QCLuceneIndexWriter::getMinMergeDocs() const |
| { |
| return qint32(d->writer->getMinMergeDocs()); |
| } |
| |
| void QCLuceneIndexWriter::setMinMergeDocs(qint32 value) |
| { |
| d->writer->setMinMergeDocs(int32_t(value)); |
| } |
| |
| qint32 QCLuceneIndexWriter::getMaxMergeDocs() const |
| { |
| return qint32(d->writer->getMaxMergeDocs()); |
| } |
| |
| void QCLuceneIndexWriter::setMaxMergeDocs(qint32 value) |
| { |
| d->writer->setMaxMergeDocs(int32_t(value)); |
| } |
| |
| bool QCLuceneIndexWriter::getUseCompoundFile() const |
| { |
| return d->writer->getUseCompoundFile(); |
| } |
| |
| void QCLuceneIndexWriter::setUseCompoundFile(bool value) |
| { |
| d->writer->setUseCompoundFile(value); |
| } |
| |
| QT_END_NAMESPACE |