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