001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.search;
016    
017    import com.liferay.portal.kernel.cluster.Priority;
018    import com.liferay.portal.kernel.log.Log;
019    import com.liferay.portal.kernel.log.LogFactoryUtil;
020    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
021    import com.liferay.portal.kernel.util.InstanceFactory;
022    import com.liferay.portal.kernel.util.PortalClassLoaderUtil;
023    
024    /**
025     * @author Bruno Farache
026     * @author Carlos Sierra Andr??s
027     * @author Marcellus Tavares
028     */
029    @DoPrivileged
030    public class BaseSearchEngine implements SearchEngine {
031    
032            /**
033             * @throws SearchException
034             */
035            @Override
036            public String backup(long companyId, String backupName)
037                    throws SearchException {
038    
039                    return null;
040            }
041    
042            @Override
043            public BooleanClauseFactory getBooleanClauseFactory() {
044                    if (_booleanClauseFactory == null) {
045                            ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
046    
047                            String className =
048                                    "com.liferay.portal.search.generic.BooleanClauseFactoryImpl";
049    
050                            try {
051                                    _booleanClauseFactory =
052                                            (BooleanClauseFactory)InstanceFactory.newInstance(
053                                                    classLoader, className);
054                            }
055                            catch (Exception e) {
056                                    _log.fatal(
057                                            "Unable to locate appropriate BooleanClauseFactory", e);
058                            }
059                    }
060    
061                    return _booleanClauseFactory;
062            }
063    
064            @Override
065            public BooleanQueryFactory getBooleanQueryFactory() {
066                    if (_booleanQueryFactory != null) {
067                            return _booleanQueryFactory;
068                    }
069    
070                    ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
071    
072                    String className =
073                            "com.liferay.portal.search.lucene.BooleanQueryFactoryImpl";
074    
075                    if (!isLuceneBased()) {
076                            className =
077                                    "com.liferay.portal.search.generic.BooleanQueryFactoryImpl";
078                    }
079    
080                    try {
081                            _booleanQueryFactory =
082                                    (BooleanQueryFactory)InstanceFactory.newInstance(
083                                            classLoader, className);
084                    }
085                    catch (Exception e) {
086                            _log.fatal("Unable to locate appropriate BooleanQueryFactory", e);
087                    }
088    
089                    return _booleanQueryFactory;
090            }
091    
092            @Override
093            public Priority getClusteredWritePriority() {
094                    return _clusteredWritePriority;
095            }
096    
097            @Override
098            public IndexSearcher getIndexSearcher() {
099                    return _indexSearcher;
100            }
101    
102            @Override
103            public IndexWriter getIndexWriter() {
104                    return _indexWriter;
105            }
106    
107            @Override
108            public TermQueryFactory getTermQueryFactory() {
109                    if (_termQueryFactory != null) {
110                            return _termQueryFactory;
111                    }
112    
113                    ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
114    
115                    String className =
116                            "com.liferay.portal.search.lucene.TermQueryFactoryImpl";
117    
118                    if (!isLuceneBased()) {
119                            className =
120                                    "com.liferay.portal.search.generic.TermQueryFactoryImpl";
121                    }
122    
123                    try {
124                            _termQueryFactory = (TermQueryFactory)InstanceFactory.newInstance(
125                                    classLoader, className);
126                    }
127                    catch (Exception e) {
128                            _log.fatal("Unable to locate appropriate BooleanQueryFactory", e);
129                    }
130    
131                    return _termQueryFactory;
132            }
133    
134            @Override
135            public TermRangeQueryFactory getTermRangeQueryFactory() {
136                    if (_termRangeQueryFactory != null) {
137                            return _termRangeQueryFactory;
138                    }
139    
140                    ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
141    
142                    String className =
143                            "com.liferay.portal.search.lucene.TermRangeQueryFactoryImpl";
144    
145                    if (!isLuceneBased()) {
146                            className =
147                                    "com.liferay.portal.search.generic." +
148                                            "TermRangeQueryFactoryImpl";
149                    }
150    
151                    try {
152                            _termRangeQueryFactory =
153                                    (TermRangeQueryFactory)InstanceFactory.newInstance(
154                                            classLoader, className);
155                    }
156                    catch (Exception e) {
157                            _log.fatal("Unable to locate appropriate BooleanQueryFactory", e);
158                    }
159    
160                    return _termRangeQueryFactory;
161            }
162    
163            @Override
164            public String getVendor() {
165                    return _vendor;
166            }
167    
168            @Override
169            public void initialize(long companyId) {
170            }
171    
172            @Override
173            public boolean isClusteredWrite() {
174                    return _clusteredWrite;
175            }
176    
177            @Override
178            public boolean isLuceneBased() {
179                    return _luceneBased;
180            }
181    
182            /**
183             * @throws SearchException
184             */
185            @Override
186            public void removeBackup(long companyId, String backupName)
187                    throws SearchException {
188            }
189    
190            @Override
191            public void removeCompany(long companyId) {
192            }
193    
194            /**
195             * @throws SearchException
196             */
197            @Override
198            public void restore(long companyId, String backupName)
199                    throws SearchException {
200            }
201    
202            public void setBooleanClauseFactory(
203                    BooleanClauseFactory booleanClauseFactory) {
204    
205                    _booleanClauseFactory = booleanClauseFactory;
206            }
207    
208            public void setBooleanQueryFactory(
209                    BooleanQueryFactory booleanQueryFactory) {
210    
211                    _booleanQueryFactory = booleanQueryFactory;
212            }
213    
214            public void setClusteredWrite(boolean clusteredWrite) {
215                    _clusteredWrite = clusteredWrite;
216            }
217    
218            public void setClusteredWritePriority(Priority clusteredWritePriority) {
219                    _clusteredWritePriority = clusteredWritePriority;
220            }
221    
222            public void setIndexSearcher(IndexSearcher indexSearcher) {
223                    _indexSearcher = indexSearcher;
224            }
225    
226            public void setIndexWriter(IndexWriter indexWriter) {
227                    _indexWriter = indexWriter;
228            }
229    
230            public void setLuceneBased(boolean luceneBased) {
231                    _luceneBased = luceneBased;
232            }
233    
234            public void setTermQueryFactory(TermQueryFactory termQueryFactory) {
235                    _termQueryFactory = termQueryFactory;
236            }
237    
238            public void setTermRangeQueryFactory(
239                    TermRangeQueryFactory termRangeQueryFactory) {
240    
241                    _termRangeQueryFactory = termRangeQueryFactory;
242            }
243    
244            public void setVendor(String vendor) {
245                    _vendor = vendor;
246            }
247    
248            private static final Log _log = LogFactoryUtil.getLog(
249                    BaseSearchEngine.class);
250    
251            private BooleanClauseFactory _booleanClauseFactory;
252            private BooleanQueryFactory _booleanQueryFactory;
253            private boolean _clusteredWrite;
254            private Priority _clusteredWritePriority;
255            private IndexSearcher _indexSearcher = new DummyIndexSearcher();
256            private IndexWriter _indexWriter = new DummyIndexWriter();
257            private boolean _luceneBased;
258            private TermQueryFactory _termQueryFactory;
259            private TermRangeQueryFactory _termRangeQueryFactory;
260            private String _vendor;
261    
262    }