001    /**
002     * Copyright (c) 2000-2013 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     */
027    @DoPrivileged
028    public class BaseSearchEngine implements SearchEngine {
029    
030            public BooleanClauseFactory getBooleanClauseFactory() {
031                    if (_booleanClauseFactory == null) {
032                            ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
033    
034                            String className =
035                                    "com.liferay.portal.search.generic.BooleanClauseFactoryImpl";
036    
037                            try {
038                                    _booleanClauseFactory =
039                                            (BooleanClauseFactory)InstanceFactory.newInstance(
040                                                    classLoader, className);
041                            }
042                            catch (Exception e) {
043                                    _log.fatal(
044                                            "Unable to locate appropriate BooleanClauseFactory", e);
045                            }
046                    }
047    
048                    return _booleanClauseFactory;
049            }
050    
051            public BooleanQueryFactory getBooleanQueryFactory() {
052                    if (_booleanQueryFactory == null) {
053                            ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
054    
055                            String className =
056                                    "com.liferay.portal.search.lucene.BooleanQueryFactoryImpl";
057    
058                            if (!isLuceneBased()) {
059                                    className =
060                                            "com.liferay.portal.search.generic.BooleanQueryFactoryImpl";
061                            }
062    
063                            try {
064                                    _booleanQueryFactory =
065                                            (BooleanQueryFactory)InstanceFactory.newInstance(
066                                                    classLoader, className);
067                            }
068                            catch (Exception e) {
069                                    _log.fatal(
070                                            "Unable to locate appropriate BooleanQueryFactory", e);
071                            }
072                    }
073    
074                    return _booleanQueryFactory;
075            }
076    
077            public Priority getClusteredWritePriority() {
078                    return _clusteredWritePriority;
079            }
080    
081            public IndexSearcher getIndexSearcher() {
082                    return _indexSearcher;
083            }
084    
085            public IndexWriter getIndexWriter() {
086                    return _indexWriter;
087            }
088    
089            public TermQueryFactory getTermQueryFactory() {
090                    if (_termQueryFactory == null) {
091                            ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
092    
093                            String className =
094                                    "com.liferay.portal.search.lucene.TermQueryFactoryImpl";
095    
096                            if (!isLuceneBased()) {
097                                    className =
098                                            "com.liferay.portal.search.generic.TermQueryFactoryImpl";
099                            }
100    
101                            try {
102                                    _termQueryFactory =
103                                            (TermQueryFactory)InstanceFactory.newInstance(
104                                                    classLoader, className);
105                            }
106                            catch (Exception e) {
107                                    _log.fatal(
108                                            "Unable to locate appropriate BooleanQueryFactory", e);
109                            }
110                    }
111    
112                    return _termQueryFactory;
113            }
114    
115            public TermRangeQueryFactory getTermRangeQueryFactory() {
116                    if (_termRangeQueryFactory == null) {
117                            ClassLoader classLoader = PortalClassLoaderUtil.getClassLoader();
118    
119                            String className =
120                                    "com.liferay.portal.search.lucene.TermRangeQueryFactoryImpl";
121    
122                            if (!isLuceneBased()) {
123                                    className =
124                                            "com.liferay.portal.search.generic." +
125                                                    "TermRangeQueryFactoryImpl";
126                            }
127    
128                            try {
129                                    _termRangeQueryFactory =
130                                            (TermRangeQueryFactory)InstanceFactory.newInstance(
131                                                    classLoader, className);
132                            }
133                            catch (Exception e) {
134                                    _log.fatal(
135                                            "Unable to locate appropriate BooleanQueryFactory", e);
136                            }
137                    }
138    
139                    return _termRangeQueryFactory;
140            }
141    
142            public String getVendor() {
143                    return _vendor;
144            }
145    
146            public boolean isClusteredWrite() {
147                    return _clusteredWrite;
148            }
149    
150            public boolean isLuceneBased() {
151                    return _luceneBased;
152            }
153    
154            public void setBooleanClauseFactory(
155                    BooleanClauseFactory booleanClauseFactory) {
156    
157                    _booleanClauseFactory = booleanClauseFactory;
158            }
159    
160            public void setBooleanQueryFactory(
161                    BooleanQueryFactory booleanQueryFactory) {
162    
163                    _booleanQueryFactory = booleanQueryFactory;
164            }
165    
166            public void setClusteredWrite(boolean clusteredWrite) {
167                    _clusteredWrite = clusteredWrite;
168            }
169    
170            public void setClusteredWritePriority(Priority clusteredWritePriority) {
171                    _clusteredWritePriority = clusteredWritePriority;
172            }
173    
174            public void setIndexSearcher(IndexSearcher indexSearcher) {
175                    _indexSearcher = indexSearcher;
176            }
177    
178            public void setIndexWriter(IndexWriter indexWriter) {
179                    _indexWriter = indexWriter;
180            }
181    
182            public void setLuceneBased(boolean luceneBased) {
183                    _luceneBased = luceneBased;
184            }
185    
186            public void setTermQueryFactory(TermQueryFactory termQueryFactory) {
187                    _termQueryFactory = termQueryFactory;
188            }
189    
190            public void setTermRangeQueryFactory(
191                    TermRangeQueryFactory termRangeQueryFactory) {
192    
193                    _termRangeQueryFactory = termRangeQueryFactory;
194            }
195    
196            public void setVendor(String vendor) {
197                    _vendor = vendor;
198            }
199    
200            private static Log _log = LogFactoryUtil.getLog(BaseSearchEngine.class);
201    
202            private BooleanClauseFactory _booleanClauseFactory;
203            private BooleanQueryFactory _booleanQueryFactory;
204            private boolean _clusteredWrite;
205            private Priority _clusteredWritePriority;
206            private IndexSearcher _indexSearcher;
207            private IndexWriter _indexWriter;
208            private boolean _luceneBased;
209            private TermQueryFactory _termQueryFactory;
210            private TermRangeQueryFactory _termRangeQueryFactory;
211            private String _vendor;
212    
213    }