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