1 /////////////////////////////////////////////////////////////////////////////
2 // Copyright (c) 2009-2014 Alan Wright. All rights reserved.
3 // Distributable under the terms of either the Apache License (Version 2.0)
4 // or the GNU Lesser General Public License.
5 /////////////////////////////////////////////////////////////////////////////
6 
7 #ifndef LUCENE_H
8 #define LUCENE_H
9 
10 #include "Config.h"
11 
12 #include <cwctype>
13 #include <cwchar>
14 #include <sys/types.h>
15 #include <sstream>
16 #include <string>
17 #include <algorithm>
18 #include <limits>
19 #include <stdexcept>
20 
21 #ifdef LPP_USE_BOOST_INTEGER
22 #include <boost/cstdint.hpp>
23 #endif
24 
25 #include <boost/filesystem/fstream.hpp>
26 #include <boost/variant.hpp>
27 #include <boost/shared_ptr.hpp>
28 #include <boost/weak_ptr.hpp>
29 
30 #ifdef LPP_USE_BOOST_INTEGER
31 using boost::int8_t;
32 using boost::uint8_t;
33 using boost::int16_t;
34 using boost::uint16_t;
35 using boost::int32_t;
36 using boost::uint32_t;
37 using boost::int64_t;
38 using boost::uint64_t;
39 #endif
40 
41 #define SIZEOF_ARRAY(arr) (sizeof(arr) / sizeof((arr)[0]))
42 
43 #include "LuceneTypes.h"
44 #include "LuceneAllocator.h"
45 
46 namespace boost {
47 
48 struct blank;
49 class thread;
50 class any;
51 template < typename Signature > class function;
52 namespace interprocess {
53 
54 class file_lock;
55 }
56 namespace posix_time {
57 
58 class ptime;
59 }
60 
61 }
62 
63 namespace Lucene {
64 
65 typedef std::basic_string< char, std::char_traits<char> > SingleString;
66 typedef std::basic_ostringstream< char, std::char_traits<char> > SingleStringStream;
67 typedef std::basic_string< wchar_t, std::char_traits<wchar_t> > String;
68 typedef std::basic_ostringstream< wchar_t, std::char_traits<wchar_t> > StringStream;
69 
70 const std::basic_string< wchar_t, std::char_traits<wchar_t> > EmptyString;
71 
72 typedef boost::shared_ptr<boost::interprocess::file_lock> filelockPtr;
73 typedef boost::shared_ptr<boost::thread> threadPtr;
74 
75 typedef boost::shared_ptr<boost::filesystem::ofstream> ofstreamPtr;
76 typedef boost::shared_ptr<boost::filesystem::ifstream> ifstreamPtr;
77 typedef boost::shared_ptr<std::locale> localePtr;
78 }
79 
80 #include "LuceneFactory.h"
81 #include "LuceneException.h"
82 #include "Array.h"
83 #include "Collection.h"
84 #include "Map.h"
85 #include "Set.h"
86 #include "HashMap.h"
87 #include "HashSet.h"
88 #include "Constants.h"
89 
90 namespace Lucene {
91 
92 typedef Array<uint8_t> ByteArray;
93 typedef Array<int32_t> IntArray;
94 typedef Array<int64_t> LongArray;
95 typedef Array<wchar_t> CharArray;
96 typedef Array<double> DoubleArray;
97 
98 template <class TYPE>
99 struct luceneEquals {
operatorluceneEquals100     inline bool operator()(const TYPE& first, const TYPE& second) const {
101         return first ? first->equals(second) : (!first && !second);
102     }
103 };
104 
105 template <class TYPE>
106 struct luceneEqualTo {
luceneEqualToluceneEqualTo107     luceneEqualTo(const TYPE& type) : equalType(type) {}
operatorluceneEqualTo108     inline bool operator()(const TYPE& other) const {
109         return equalType->equals(other);
110     }
111     const TYPE& equalType;
112 };
113 
114 template <class TYPE>
115 struct luceneWeakEquals {
operatorluceneWeakEquals116     inline bool operator()(const TYPE& first, const TYPE& second) const {
117         if (first.expired() || second.expired()) {
118             return (first.expired() && second.expired());
119         }
120         return first.lock()->equals(second.lock());
121     }
122 };
123 
124 template <class TYPE>
125 struct luceneHash {
operatorluceneHash126     std::size_t operator()(const TYPE& type) const {
127         return type ? type->hashCode() : 0;
128     }
129 };
130 
131 template <class TYPE>
132 struct luceneWeakHash {
operatorluceneWeakHash133     std::size_t operator()(const TYPE& type) const {
134         return type.expired() ? 0 : type.lock()->hashCode();
135     }
136 };
137 
138 template <class TYPE>
139 struct luceneCompare {
operatorluceneCompare140     inline bool operator()(const TYPE& first, const TYPE& second) const {
141         if (!second) {
142             return false;
143         }
144         if (!first) {
145             return true;
146         }
147         return (first->compareTo(second) < 0);
148     }
149 };
150 
151 typedef boost::blank VariantNull;
152 typedef boost::variant<String, int32_t, int64_t, double, ReaderPtr, ByteArray, VariantNull> FieldsData;
153 typedef boost::variant<String, uint8_t, int32_t, int64_t, double, VariantNull> ComparableValue;
154 typedef boost::variant<int32_t, int64_t, double, VariantNull> NumericValue;
155 typedef boost::variant<String, VariantNull> StringValue;
156 typedef boost::variant<Collection<uint8_t>, Collection<int32_t>, Collection<double>, VariantNull> CollectionValue;
157 
158 typedef HashSet< SegmentInfoPtr, luceneHash<SegmentInfoPtr>, luceneEquals<SegmentInfoPtr> > SetSegmentInfo;
159 typedef HashSet< MergeThreadPtr, luceneHash<MergeThreadPtr>, luceneEquals<MergeThreadPtr> > SetMergeThread;
160 typedef HashSet< OneMergePtr, luceneHash<OneMergePtr>, luceneEquals<OneMergePtr> > SetOneMerge;
161 typedef HashSet< QueryPtr, luceneHash<QueryPtr>, luceneEquals<QueryPtr> > SetQuery;
162 typedef HashSet< TermPtr, luceneHash<TermPtr>, luceneEquals<TermPtr> > SetTerm;
163 typedef HashSet< BooleanClausePtr, luceneHash<BooleanClausePtr>, luceneEquals<BooleanClausePtr> > SetBooleanClause;
164 typedef HashSet< ReaderFieldPtr, luceneHash<ReaderFieldPtr>, luceneEquals<ReaderFieldPtr> > SetReaderField;
165 typedef HashSet<ByteArray> SetByteArray;
166 
167 typedef HashMap< String, String > MapStringString;
168 typedef HashMap< wchar_t, NormalizeCharMapPtr > MapCharNormalizeCharMap;
169 typedef HashMap< String, AnalyzerPtr > MapStringAnalyzer;
170 typedef HashMap< String, ByteArray > MapStringByteArray;
171 typedef HashMap< String, int32_t > MapStringInt;
172 typedef HashMap< String, FieldInfoPtr > MapStringFieldInfo;
173 typedef HashMap< String, Collection<TermVectorEntryPtr> > MapStringCollectionTermVectorEntry;
174 typedef HashMap< String, RefCountPtr > MapStringRefCount;
175 typedef HashMap< int32_t, TermVectorsPositionInfoPtr > MapIntTermVectorsPositionInfo;
176 typedef HashMap< String, MapIntTermVectorsPositionInfo > MapStringMapIntTermVectorsPositionInfo;
177 typedef HashMap< String, NormPtr > MapStringNorm;
178 typedef HashMap< String, TermVectorEntryPtr > MapStringTermVectorEntry;
179 typedef HashMap< String, RAMFilePtr > MapStringRAMFile;
180 typedef HashMap< int32_t, ByteArray > MapIntByteArray;
181 typedef HashMap< int32_t, FilterItemPtr > MapIntFilterItem;
182 typedef HashMap< int32_t, double > MapIntDouble;
183 typedef HashMap< int64_t, int32_t > MapLongInt;
184 typedef HashMap< String, double > MapStringDouble;
185 typedef HashMap< int32_t, CachePtr > MapStringCache;
186 typedef HashMap< String, LockPtr > MapStringLock;
187 
188 typedef HashMap< SegmentInfoPtr, SegmentReaderPtr, luceneHash<SegmentInfoPtr>, luceneEquals<SegmentInfoPtr> > MapSegmentInfoSegmentReader;
189 typedef HashMap< SegmentInfoPtr, int32_t, luceneHash<SegmentInfoPtr>, luceneEquals<SegmentInfoPtr> > MapSegmentInfoInt;
190 typedef HashMap< DocFieldConsumerPerThreadPtr, Collection<DocFieldConsumerPerFieldPtr>, luceneHash<DocFieldConsumerPerThreadPtr>, luceneEquals<DocFieldConsumerPerThreadPtr> > MapDocFieldConsumerPerThreadCollectionDocFieldConsumerPerField;
191 typedef HashMap< InvertedDocConsumerPerThreadPtr, Collection<InvertedDocConsumerPerFieldPtr>, luceneHash<InvertedDocConsumerPerThreadPtr>, luceneEquals<InvertedDocConsumerPerThreadPtr> > MapInvertedDocConsumerPerThreadCollectionInvertedDocConsumerPerField;
192 typedef HashMap< InvertedDocEndConsumerPerThreadPtr, Collection<InvertedDocEndConsumerPerFieldPtr>, luceneHash<InvertedDocEndConsumerPerThreadPtr>, luceneEquals<InvertedDocEndConsumerPerThreadPtr> > MapInvertedDocEndConsumerPerThreadCollectionInvertedDocEndConsumerPerField;
193 typedef HashMap< TermsHashConsumerPerThreadPtr, Collection<TermsHashConsumerPerFieldPtr>, luceneHash<TermsHashConsumerPerThreadPtr>, luceneEquals<TermsHashConsumerPerThreadPtr> > MapTermsHashConsumerPerThreadCollectionTermsHashConsumerPerField;
194 typedef HashMap< FieldInfoPtr, Collection<NormsWriterPerFieldPtr>, luceneHash<FieldInfoPtr>, luceneEquals<FieldInfoPtr> > MapFieldInfoCollectionNormsWriterPerField;
195 typedef HashMap< IndexReaderPtr, HashSet<String>, luceneHash<IndexReaderPtr>, luceneEquals<IndexReaderPtr> > MapIndexReaderSetString;
196 typedef HashMap< TermPtr, int32_t, luceneHash<TermPtr>, luceneEquals<TermPtr> > MapTermInt;
197 typedef HashMap< QueryPtr, int32_t, luceneHash<QueryPtr>, luceneEquals<QueryPtr> > MapQueryInt;
198 typedef HashMap< EntryPtr, boost::any, luceneHash<EntryPtr>, luceneEquals<EntryPtr> > MapEntryAny;
199 typedef HashMap< PhrasePositionsPtr, LuceneObjectPtr, luceneHash<PhrasePositionsPtr>, luceneEquals<PhrasePositionsPtr> > MapPhrasePositionsLuceneObject;
200 typedef HashMap< ReaderFieldPtr, SetReaderField, luceneHash<ReaderFieldPtr>, luceneEquals<ReaderFieldPtr> > MapReaderFieldSetReaderField;
201 
202 typedef WeakHashMap< LuceneObjectWeakPtr, LuceneObjectPtr, luceneWeakHash<LuceneObjectWeakPtr>, luceneWeakEquals<LuceneObjectWeakPtr> > WeakMapObjectObject;
203 typedef WeakHashMap< LuceneObjectWeakPtr, MapEntryAny, luceneWeakHash<LuceneObjectWeakPtr>, luceneWeakEquals<LuceneObjectWeakPtr> > WeakMapLuceneObjectMapEntryAny;
204 
205 typedef Map< String, AttributePtr > MapStringAttribute;
206 typedef Map< int64_t, DocumentsWriterThreadStatePtr > MapThreadDocumentsWriterThreadState;
207 typedef Map< String, IndexReaderPtr > MapStringIndexReader;
208 typedef Map< TermPtr, NumPtr, luceneCompare<TermPtr> > MapTermNum;
209 
210 typedef boost::function<bool (const TermVectorEntryPtr&, const TermVectorEntryPtr&)> TermVectorEntryComparator;
211 
212 template < class KEY, class VALUE, class HASH = boost::hash<KEY>, class EQUAL = std::equal_to<KEY> > class SimpleLRUCache;
213 typedef SimpleLRUCache< TermPtr, TermInfoPtr, luceneHash<TermPtr>, luceneEquals<TermPtr> > TermInfoCache;
214 typedef boost::shared_ptr<TermInfoCache> TermInfoCachePtr;
215 }
216 
217 #include "Synchronize.h"
218 #include "CycleCheck.h"
219 #if defined(LPP_BUILDING_LIB) || defined(LPP_EXPOSE_INTERNAL)
220 #define INTERNAL public
221 #else
222 #define INTERNAL protected
223 #endif
224 
225 #endif
226