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