← Back to branch summary

~ubuntu-branches/ubuntu/raring/clucene-core/raring-proposed

« back to all changes in this revision

Viewing changes to src/core/CLucene/index/IndexModifier.cpp

  • Committer: Package Import Robot
  • Author(s): Fathi Boudra
  • Date: 2012-08-11 09:33:38 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120811093338-fgrx41ftqew3qt6a
Tags: 2.3.3.4-1
http://bugs.debian.org/661703
* New upstream release (Closes: #661703).
* Convert package to multiarch.
* Drop obsolete patches:
  - 01_add_missing_include_bug505667.diff
  - 02_posixness_fix_bug530308.diff
* Add patches:
  - Fixing_ZLIB_configuration_in_shared_CMakeLists.patch
  - Fix-pkgconfig-file-by-adding-clucene-shared-library.patch
  - Install-contribs-lib.patch
  - multiarch.patch
* Update debian/compat: bump to 8.
* Update debian/control:
  - update build dependencies (add cmake, libboost-dev and libz-dev).
  - bump Standards-Version to 3.9.3.
  - rename packages due to ABI bump: libclucene0ldbl -> libclucene-core1.
  - add libclucene-contribs1 package.
* Update debian/rules:
  - rewrite to use CMake.
  - add multiarch support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/core/CLucene/index/IndexModifier.cpp
 
1
/*------------------------------------------------------------------------------
 
2
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
 
3
*
 
4
* Distributable under the terms of either the Apache License (Version 2.0) or
 
5
* the GNU Lesser General Public License, as specified in the COPYING file.
 
6
------------------------------------------------------------------------------*/
 
7
/*------------------------------------------------------------------------------
 
8
* Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team
 
9
*
 
10
* Distributable under the terms of either the Apache License (Version 2.0) or
 
11
* the GNU Lesser General Public License, as specified in the COPYING file.
 
12
------------------------------------------------------------------------------*/
 
13
#include "CLucene/_ApiHeader.h"
 
14
#include "IndexModifier.h"
 
15
 
 
16
#include "IndexWriter.h"
 
17
#include "IndexReader.h"
 
18
#include "CLucene/store/FSDirectory.h"
 
19
#include "CLucene/document/Document.h"
 
20
#include "MergeScheduler.h"
 
21
 
 
22
CL_NS_DEF(index)
 
23
CL_NS_USE(util)
 
24
CL_NS_USE(store)
 
25
CL_NS_USE(analysis)
 
26
CL_NS_USE(document)
 
27
 
 
28
IndexModifier::IndexModifier(Directory* directory, Analyzer* analyzer, bool create) {
 
29
        init(directory, analyzer, create);
 
30
}
 
31
 
 
32
IndexModifier::IndexModifier(const char* dirName, Analyzer* analyzer, bool create) {
 
33
        Directory* dir = FSDirectory::getDirectory(dirName);
 
34
        init(dir, analyzer, create);
 
35
}
 
36
 
 
37
void IndexModifier::init(Directory* directory, Analyzer* analyzer, bool create) {
 
38
        indexWriter = NULL;
 
39
        indexReader = NULL;
 
40
        open = false;
 
41
        infoStream = NULL;
 
42
 
 
43
        useCompoundFile = true;
 
44
        this->maxBufferedDocs = IndexWriter::DEFAULT_MAX_BUFFERED_DOCS;
 
45
        this->maxFieldLength = IndexWriter::DEFAULT_MAX_FIELD_LENGTH;
 
46
        this->mergeFactor = IndexWriter::DEFAULT_MERGE_FACTOR;
 
47
 
 
48
        this->directory = _CL_POINTER(directory);
 
49
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
50
        this->analyzer = analyzer;
 
51
        indexWriter = _CLNEW IndexWriter(directory, analyzer, create);
 
52
        open = true;
 
53
}
 
54
 
 
55
IndexModifier::~IndexModifier(){
 
56
        if (open) {
 
57
                close();
 
58
        }
 
59
}
 
60
 
 
61
void IndexModifier::assureOpen() const{
 
62
        if (!open) {
 
63
                _CLTHROWA(CL_ERR_IllegalState,"Index is closed");
 
64
        }
 
65
}
 
66
 
 
67
void IndexModifier::createIndexWriter(bool create) {
 
68
        if (indexWriter == NULL) {
 
69
                if (indexReader != NULL) {
 
70
                        indexReader->close();
 
71
                        _CLDELETE(indexReader);
 
72
                }
 
73
 
 
74
                indexWriter = _CLNEW IndexWriter(directory, analyzer, false);
 
75
        // IndexModifier cannot use ConcurrentMergeScheduler
 
76
        // because it synchronizes on the directory which can
 
77
        // cause deadlock
 
78
        indexWriter->setMergeScheduler(_CLNEW SerialMergeScheduler());
 
79
        indexWriter->setInfoStream(infoStream);
 
80
                indexWriter->setUseCompoundFile(useCompoundFile);
 
81
        if (maxBufferedDocs != IndexWriter::DISABLE_AUTO_FLUSH)
 
82
            indexWriter->setMaxBufferedDocs(maxBufferedDocs);
 
83
                indexWriter->setMaxFieldLength(maxFieldLength);
 
84
                indexWriter->setMergeFactor(mergeFactor);
 
85
        }
 
86
}
 
87
 
 
88
void IndexModifier::createIndexReader() {
 
89
        if (indexReader == NULL) {
 
90
                if (indexWriter != NULL) {
 
91
                        indexWriter->close();
 
92
                        _CLDELETE(indexWriter);
 
93
                }
 
94
                indexReader = IndexReader::open(directory);
 
95
        }
 
96
}
 
97
 
 
98
void IndexModifier::flush() {
 
99
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
100
        assureOpen();
 
101
        if (indexWriter != NULL) {
 
102
                indexWriter->close();
 
103
                _CLDELETE(indexWriter);
 
104
                createIndexWriter();
 
105
        } else {
 
106
                indexReader->close();
 
107
                _CLDELETE(indexReader);
 
108
                createIndexReader();
 
109
        }
 
110
}
 
111
 
 
112
void IndexModifier::addDocument(Document* doc, Analyzer* docAnalyzer) {
 
113
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
114
        assureOpen();
 
115
        createIndexWriter();
 
116
        if (docAnalyzer != NULL)
 
117
                indexWriter->addDocument(doc, docAnalyzer);
 
118
        else
 
119
                indexWriter->addDocument(doc);
 
120
}
 
121
 
 
122
int32_t IndexModifier::deleteDocuments(Term* term) {
 
123
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
124
        assureOpen();
 
125
        createIndexReader();
 
126
        return indexReader->deleteDocuments(term);
 
127
}
 
128
 
 
129
void IndexModifier::deleteDocument(int32_t docNum) {
 
130
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
131
        assureOpen();
 
132
        createIndexReader();
 
133
        indexReader->deleteDocument(docNum);
 
134
}
 
135
 
 
136
int32_t IndexModifier::docCount() {
 
137
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
138
        assureOpen();
 
139
        if (indexWriter != NULL)
 
140
                return indexWriter->docCount();
 
141
        else
 
142
                return indexReader->numDocs();
 
143
}
 
144
 
 
145
void IndexModifier::optimize() {
 
146
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
147
        assureOpen();
 
148
        createIndexWriter();
 
149
        indexWriter->optimize();
 
150
}
 
151
 
 
152
void IndexModifier::setUseCompoundFile(bool useCompoundFile) {
 
153
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
154
        assureOpen();
 
155
        if (indexWriter != NULL)
 
156
                indexWriter->setUseCompoundFile(useCompoundFile);
 
157
        this->useCompoundFile = useCompoundFile;
 
158
}
 
159
 
 
160
bool IndexModifier::getUseCompoundFile() {
 
161
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
162
        assureOpen();
 
163
        createIndexWriter();
 
164
        return indexWriter->getUseCompoundFile();
 
165
}
 
166
 
 
167
void IndexModifier::setMaxFieldLength(int32_t maxFieldLength) {
 
168
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
169
        assureOpen();
 
170
        if (indexWriter != NULL)
 
171
                indexWriter->setMaxFieldLength(maxFieldLength);
 
172
        this->maxFieldLength = maxFieldLength;
 
173
}
 
174
 
 
175
int32_t IndexModifier::getMaxFieldLength() {
 
176
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
177
        assureOpen();
 
178
        createIndexWriter();
 
179
        return indexWriter->getMaxFieldLength();
 
180
}
 
181
 
 
182
void IndexModifier::setMaxBufferedDocs(int32_t maxBufferedDocs) {
 
183
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
184
        assureOpen();
 
185
        if (indexWriter != NULL)
 
186
                indexWriter->setMaxBufferedDocs(maxBufferedDocs);
 
187
        this->maxBufferedDocs = maxBufferedDocs;
 
188
}
 
189
 
 
190
int32_t IndexModifier::getMaxBufferedDocs() {
 
191
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
192
        assureOpen();
 
193
        createIndexWriter();
 
194
        return indexWriter->getMaxBufferedDocs();
 
195
}
 
196
void IndexModifier::setMergeFactor(int32_t mergeFactor) {
 
197
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
198
        assureOpen();
 
199
        if (indexWriter != NULL)
 
200
                indexWriter->setMergeFactor(mergeFactor);
 
201
        this->mergeFactor = mergeFactor;
 
202
}
 
203
 
 
204
int32_t IndexModifier::getMergeFactor() {
 
205
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
206
        assureOpen();
 
207
        createIndexWriter();
 
208
        return indexWriter->getMergeFactor();
 
209
}
 
210
 
 
211
void IndexModifier::close() {
 
212
        if (!open)
 
213
                _CLTHROWA(CL_ERR_IllegalState, "Index is closed already");
 
214
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
215
        if (indexWriter != NULL) {
 
216
                indexWriter->close();
 
217
                _CLDELETE(indexWriter);
 
218
        } else if (indexReader != NULL) {
 
219
                indexReader->close();
 
220
                _CLDELETE(indexReader);
 
221
        }
 
222
        _CLDECDELETE(directory)
 
223
        open = false;
 
224
}
 
225
 
 
226
string IndexModifier::toString() const{
 
227
        return string("Index@") + directory->toString();
 
228
}
 
229
 
 
230
 
 
231
 
 
232
int64_t IndexModifier::getCurrentVersion() const{
 
233
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
234
        return IndexReader::getCurrentVersion(directory);
 
235
}
 
236
 
 
237
TermDocs* IndexModifier::termDocs(Term* term){
 
238
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
239
        assureOpen();
 
240
        createIndexReader();
 
241
        return indexReader->termDocs(term);
 
242
}
 
243
 
 
244
TermEnum* IndexModifier::terms(Term* term){
 
245
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
246
        assureOpen();
 
247
        createIndexReader();
 
248
        if ( term != NULL )
 
249
                return indexReader->terms(term);
 
250
        else
 
251
                return indexReader->terms();
 
252
}
 
253
 
 
254
 
 
255
  CL_NS(document)::Document* IndexModifier::document(const int32_t n){
 
256
    Document* ret = _CLNEW Document;
 
257
    if (!document(n, *ret) )
 
258
        _CLDELETE(ret);
 
259
    return ret;
 
260
  }
 
261
bool IndexModifier::document(int32_t n, CL_NS(document)::Document* doc){
 
262
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
263
        assureOpen();
 
264
        createIndexReader();
 
265
        return indexReader->document(n, *doc);
 
266
}
 
267
bool IndexModifier::document(int32_t n, CL_NS(document)::Document& doc){
 
268
        SCOPED_LOCK_MUTEX(directory->THIS_LOCK)
 
269
        assureOpen();
 
270
        createIndexReader();
 
271
        return indexReader->document(n, doc);
 
272
}
 
273
CL_NS(store)::Directory* IndexModifier::getDirectory(){
 
274
        return directory;
 
275
}
 
276
 
 
277
CL_NS_END