001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.journal.model.JournalContentSearch;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the journal content search service. This utility wraps {@link JournalContentSearchPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see JournalContentSearchPersistence
037     * @see JournalContentSearchPersistenceImpl
038     * @generated
039     */
040    public class JournalContentSearchUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(JournalContentSearch journalContentSearch) {
058                    getPersistence().clearCache(journalContentSearch);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<JournalContentSearch> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<JournalContentSearch> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalContentSearch> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
099             */
100            public static JournalContentSearch remove(
101                    JournalContentSearch journalContentSearch) throws SystemException {
102                    return getPersistence().remove(journalContentSearch);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
107             */
108            public static JournalContentSearch update(
109                    JournalContentSearch journalContentSearch, boolean merge)
110                    throws SystemException {
111                    return getPersistence().update(journalContentSearch, merge);
112            }
113    
114            /**
115             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
116             */
117            public static JournalContentSearch update(
118                    JournalContentSearch journalContentSearch, boolean merge,
119                    ServiceContext serviceContext) throws SystemException {
120                    return getPersistence()
121                                       .update(journalContentSearch, merge, serviceContext);
122            }
123    
124            /**
125            * Caches the journal content search in the entity cache if it is enabled.
126            *
127            * @param journalContentSearch the journal content search to cache
128            */
129            public static void cacheResult(
130                    com.liferay.portlet.journal.model.JournalContentSearch journalContentSearch) {
131                    getPersistence().cacheResult(journalContentSearch);
132            }
133    
134            /**
135            * Caches the journal content searchs in the entity cache if it is enabled.
136            *
137            * @param journalContentSearchs the journal content searchs to cache
138            */
139            public static void cacheResult(
140                    java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> journalContentSearchs) {
141                    getPersistence().cacheResult(journalContentSearchs);
142            }
143    
144            /**
145            * Creates a new journal content search with the primary key. Does not add the journal content search to the database.
146            *
147            * @param contentSearchId the primary key for the new journal content search
148            * @return the new journal content search
149            */
150            public static com.liferay.portlet.journal.model.JournalContentSearch create(
151                    long contentSearchId) {
152                    return getPersistence().create(contentSearchId);
153            }
154    
155            /**
156            * Removes the journal content search with the primary key from the database. Also notifies the appropriate model listeners.
157            *
158            * @param contentSearchId the primary key of the journal content search to remove
159            * @return the journal content search that was removed
160            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
161            * @throws SystemException if a system exception occurred
162            */
163            public static com.liferay.portlet.journal.model.JournalContentSearch remove(
164                    long contentSearchId)
165                    throws com.liferay.portal.kernel.exception.SystemException,
166                            com.liferay.portlet.journal.NoSuchContentSearchException {
167                    return getPersistence().remove(contentSearchId);
168            }
169    
170            public static com.liferay.portlet.journal.model.JournalContentSearch updateImpl(
171                    com.liferay.portlet.journal.model.JournalContentSearch journalContentSearch,
172                    boolean merge)
173                    throws com.liferay.portal.kernel.exception.SystemException {
174                    return getPersistence().updateImpl(journalContentSearch, merge);
175            }
176    
177            /**
178            * Finds the journal content search with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchContentSearchException} if it could not be found.
179            *
180            * @param contentSearchId the primary key of the journal content search to find
181            * @return the journal content search
182            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
183            * @throws SystemException if a system exception occurred
184            */
185            public static com.liferay.portlet.journal.model.JournalContentSearch findByPrimaryKey(
186                    long contentSearchId)
187                    throws com.liferay.portal.kernel.exception.SystemException,
188                            com.liferay.portlet.journal.NoSuchContentSearchException {
189                    return getPersistence().findByPrimaryKey(contentSearchId);
190            }
191    
192            /**
193            * Finds the journal content search with the primary key or returns <code>null</code> if it could not be found.
194            *
195            * @param contentSearchId the primary key of the journal content search to find
196            * @return the journal content search, or <code>null</code> if a journal content search with the primary key could not be found
197            * @throws SystemException if a system exception occurred
198            */
199            public static com.liferay.portlet.journal.model.JournalContentSearch fetchByPrimaryKey(
200                    long contentSearchId)
201                    throws com.liferay.portal.kernel.exception.SystemException {
202                    return getPersistence().fetchByPrimaryKey(contentSearchId);
203            }
204    
205            /**
206            * Finds all the journal content searchs where articleId = &#63;.
207            *
208            * @param articleId the article ID to search with
209            * @return the matching journal content searchs
210            * @throws SystemException if a system exception occurred
211            */
212            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId(
213                    java.lang.String articleId)
214                    throws com.liferay.portal.kernel.exception.SystemException {
215                    return getPersistence().findByArticleId(articleId);
216            }
217    
218            /**
219            * Finds a range of all the journal content searchs where articleId = &#63;.
220            *
221            * <p>
222            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
223            * </p>
224            *
225            * @param articleId the article ID to search with
226            * @param start the lower bound of the range of journal content searchs to return
227            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
228            * @return the range of matching journal content searchs
229            * @throws SystemException if a system exception occurred
230            */
231            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId(
232                    java.lang.String articleId, int start, int end)
233                    throws com.liferay.portal.kernel.exception.SystemException {
234                    return getPersistence().findByArticleId(articleId, start, end);
235            }
236    
237            /**
238            * Finds an ordered range of all the journal content searchs where articleId = &#63;.
239            *
240            * <p>
241            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
242            * </p>
243            *
244            * @param articleId the article ID to search with
245            * @param start the lower bound of the range of journal content searchs to return
246            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
247            * @param orderByComparator the comparator to order the results by
248            * @return the ordered range of matching journal content searchs
249            * @throws SystemException if a system exception occurred
250            */
251            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByArticleId(
252                    java.lang.String articleId, int start, int end,
253                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
254                    throws com.liferay.portal.kernel.exception.SystemException {
255                    return getPersistence()
256                                       .findByArticleId(articleId, start, end, orderByComparator);
257            }
258    
259            /**
260            * Finds the first journal content search in the ordered set where articleId = &#63;.
261            *
262            * <p>
263            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
264            * </p>
265            *
266            * @param articleId the article ID to search with
267            * @param orderByComparator the comparator to order the set by
268            * @return the first matching journal content search
269            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
270            * @throws SystemException if a system exception occurred
271            */
272            public static com.liferay.portlet.journal.model.JournalContentSearch findByArticleId_First(
273                    java.lang.String articleId,
274                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
275                    throws com.liferay.portal.kernel.exception.SystemException,
276                            com.liferay.portlet.journal.NoSuchContentSearchException {
277                    return getPersistence()
278                                       .findByArticleId_First(articleId, orderByComparator);
279            }
280    
281            /**
282            * Finds the last journal content search in the ordered set where articleId = &#63;.
283            *
284            * <p>
285            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
286            * </p>
287            *
288            * @param articleId the article ID to search with
289            * @param orderByComparator the comparator to order the set by
290            * @return the last matching journal content search
291            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
292            * @throws SystemException if a system exception occurred
293            */
294            public static com.liferay.portlet.journal.model.JournalContentSearch findByArticleId_Last(
295                    java.lang.String articleId,
296                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
297                    throws com.liferay.portal.kernel.exception.SystemException,
298                            com.liferay.portlet.journal.NoSuchContentSearchException {
299                    return getPersistence()
300                                       .findByArticleId_Last(articleId, orderByComparator);
301            }
302    
303            /**
304            * Finds the journal content searchs before and after the current journal content search in the ordered set where articleId = &#63;.
305            *
306            * <p>
307            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
308            * </p>
309            *
310            * @param contentSearchId the primary key of the current journal content search
311            * @param articleId the article ID to search with
312            * @param orderByComparator the comparator to order the set by
313            * @return the previous, current, and next journal content search
314            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
315            * @throws SystemException if a system exception occurred
316            */
317            public static com.liferay.portlet.journal.model.JournalContentSearch[] findByArticleId_PrevAndNext(
318                    long contentSearchId, java.lang.String articleId,
319                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
320                    throws com.liferay.portal.kernel.exception.SystemException,
321                            com.liferay.portlet.journal.NoSuchContentSearchException {
322                    return getPersistence()
323                                       .findByArticleId_PrevAndNext(contentSearchId, articleId,
324                            orderByComparator);
325            }
326    
327            /**
328            * Finds all the journal content searchs where groupId = &#63; and privateLayout = &#63;.
329            *
330            * @param groupId the group ID to search with
331            * @param privateLayout the private layout to search with
332            * @return the matching journal content searchs
333            * @throws SystemException if a system exception occurred
334            */
335            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P(
336                    long groupId, boolean privateLayout)
337                    throws com.liferay.portal.kernel.exception.SystemException {
338                    return getPersistence().findByG_P(groupId, privateLayout);
339            }
340    
341            /**
342            * Finds a range of all the journal content searchs where groupId = &#63; and privateLayout = &#63;.
343            *
344            * <p>
345            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
346            * </p>
347            *
348            * @param groupId the group ID to search with
349            * @param privateLayout the private layout to search with
350            * @param start the lower bound of the range of journal content searchs to return
351            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
352            * @return the range of matching journal content searchs
353            * @throws SystemException if a system exception occurred
354            */
355            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P(
356                    long groupId, boolean privateLayout, int start, int end)
357                    throws com.liferay.portal.kernel.exception.SystemException {
358                    return getPersistence().findByG_P(groupId, privateLayout, start, end);
359            }
360    
361            /**
362            * Finds an ordered range of all the journal content searchs where groupId = &#63; and privateLayout = &#63;.
363            *
364            * <p>
365            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
366            * </p>
367            *
368            * @param groupId the group ID to search with
369            * @param privateLayout the private layout to search with
370            * @param start the lower bound of the range of journal content searchs to return
371            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
372            * @param orderByComparator the comparator to order the results by
373            * @return the ordered range of matching journal content searchs
374            * @throws SystemException if a system exception occurred
375            */
376            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P(
377                    long groupId, boolean privateLayout, int start, int end,
378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
379                    throws com.liferay.portal.kernel.exception.SystemException {
380                    return getPersistence()
381                                       .findByG_P(groupId, privateLayout, start, end,
382                            orderByComparator);
383            }
384    
385            /**
386            * Finds the first journal content search in the ordered set where groupId = &#63; and privateLayout = &#63;.
387            *
388            * <p>
389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
390            * </p>
391            *
392            * @param groupId the group ID to search with
393            * @param privateLayout the private layout to search with
394            * @param orderByComparator the comparator to order the set by
395            * @return the first matching journal content search
396            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
397            * @throws SystemException if a system exception occurred
398            */
399            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_First(
400                    long groupId, boolean privateLayout,
401                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
402                    throws com.liferay.portal.kernel.exception.SystemException,
403                            com.liferay.portlet.journal.NoSuchContentSearchException {
404                    return getPersistence()
405                                       .findByG_P_First(groupId, privateLayout, orderByComparator);
406            }
407    
408            /**
409            * Finds the last journal content search in the ordered set where groupId = &#63; and privateLayout = &#63;.
410            *
411            * <p>
412            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
413            * </p>
414            *
415            * @param groupId the group ID to search with
416            * @param privateLayout the private layout to search with
417            * @param orderByComparator the comparator to order the set by
418            * @return the last matching journal content search
419            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
420            * @throws SystemException if a system exception occurred
421            */
422            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_Last(
423                    long groupId, boolean privateLayout,
424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
425                    throws com.liferay.portal.kernel.exception.SystemException,
426                            com.liferay.portlet.journal.NoSuchContentSearchException {
427                    return getPersistence()
428                                       .findByG_P_Last(groupId, privateLayout, orderByComparator);
429            }
430    
431            /**
432            * Finds the journal content searchs before and after the current journal content search in the ordered set where groupId = &#63; and privateLayout = &#63;.
433            *
434            * <p>
435            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
436            * </p>
437            *
438            * @param contentSearchId the primary key of the current journal content search
439            * @param groupId the group ID to search with
440            * @param privateLayout the private layout to search with
441            * @param orderByComparator the comparator to order the set by
442            * @return the previous, current, and next journal content search
443            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
444            * @throws SystemException if a system exception occurred
445            */
446            public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_PrevAndNext(
447                    long contentSearchId, long groupId, boolean privateLayout,
448                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
449                    throws com.liferay.portal.kernel.exception.SystemException,
450                            com.liferay.portlet.journal.NoSuchContentSearchException {
451                    return getPersistence()
452                                       .findByG_P_PrevAndNext(contentSearchId, groupId,
453                            privateLayout, orderByComparator);
454            }
455    
456            /**
457            * Finds all the journal content searchs where groupId = &#63; and articleId = &#63;.
458            *
459            * @param groupId the group ID to search with
460            * @param articleId the article ID to search with
461            * @return the matching journal content searchs
462            * @throws SystemException if a system exception occurred
463            */
464            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A(
465                    long groupId, java.lang.String articleId)
466                    throws com.liferay.portal.kernel.exception.SystemException {
467                    return getPersistence().findByG_A(groupId, articleId);
468            }
469    
470            /**
471            * Finds a range of all the journal content searchs where groupId = &#63; and articleId = &#63;.
472            *
473            * <p>
474            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
475            * </p>
476            *
477            * @param groupId the group ID to search with
478            * @param articleId the article ID to search with
479            * @param start the lower bound of the range of journal content searchs to return
480            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
481            * @return the range of matching journal content searchs
482            * @throws SystemException if a system exception occurred
483            */
484            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A(
485                    long groupId, java.lang.String articleId, int start, int end)
486                    throws com.liferay.portal.kernel.exception.SystemException {
487                    return getPersistence().findByG_A(groupId, articleId, start, end);
488            }
489    
490            /**
491            * Finds an ordered range of all the journal content searchs where groupId = &#63; and articleId = &#63;.
492            *
493            * <p>
494            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
495            * </p>
496            *
497            * @param groupId the group ID to search with
498            * @param articleId the article ID to search with
499            * @param start the lower bound of the range of journal content searchs to return
500            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
501            * @param orderByComparator the comparator to order the results by
502            * @return the ordered range of matching journal content searchs
503            * @throws SystemException if a system exception occurred
504            */
505            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_A(
506                    long groupId, java.lang.String articleId, int start, int end,
507                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
508                    throws com.liferay.portal.kernel.exception.SystemException {
509                    return getPersistence()
510                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
511            }
512    
513            /**
514            * Finds the first journal content search in the ordered set where groupId = &#63; and articleId = &#63;.
515            *
516            * <p>
517            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
518            * </p>
519            *
520            * @param groupId the group ID to search with
521            * @param articleId the article ID to search with
522            * @param orderByComparator the comparator to order the set by
523            * @return the first matching journal content search
524            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
525            * @throws SystemException if a system exception occurred
526            */
527            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_A_First(
528                    long groupId, java.lang.String articleId,
529                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
530                    throws com.liferay.portal.kernel.exception.SystemException,
531                            com.liferay.portlet.journal.NoSuchContentSearchException {
532                    return getPersistence()
533                                       .findByG_A_First(groupId, articleId, orderByComparator);
534            }
535    
536            /**
537            * Finds the last journal content search in the ordered set where groupId = &#63; and articleId = &#63;.
538            *
539            * <p>
540            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
541            * </p>
542            *
543            * @param groupId the group ID to search with
544            * @param articleId the article ID to search with
545            * @param orderByComparator the comparator to order the set by
546            * @return the last matching journal content search
547            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
548            * @throws SystemException if a system exception occurred
549            */
550            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_A_Last(
551                    long groupId, java.lang.String articleId,
552                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
553                    throws com.liferay.portal.kernel.exception.SystemException,
554                            com.liferay.portlet.journal.NoSuchContentSearchException {
555                    return getPersistence()
556                                       .findByG_A_Last(groupId, articleId, orderByComparator);
557            }
558    
559            /**
560            * Finds the journal content searchs before and after the current journal content search in the ordered set where groupId = &#63; and articleId = &#63;.
561            *
562            * <p>
563            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
564            * </p>
565            *
566            * @param contentSearchId the primary key of the current journal content search
567            * @param groupId the group ID to search with
568            * @param articleId the article ID to search with
569            * @param orderByComparator the comparator to order the set by
570            * @return the previous, current, and next journal content search
571            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
572            * @throws SystemException if a system exception occurred
573            */
574            public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_A_PrevAndNext(
575                    long contentSearchId, long groupId, java.lang.String articleId,
576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
577                    throws com.liferay.portal.kernel.exception.SystemException,
578                            com.liferay.portlet.journal.NoSuchContentSearchException {
579                    return getPersistence()
580                                       .findByG_A_PrevAndNext(contentSearchId, groupId, articleId,
581                            orderByComparator);
582            }
583    
584            /**
585            * Finds all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
586            *
587            * @param groupId the group ID to search with
588            * @param privateLayout the private layout to search with
589            * @param layoutId the layout ID to search with
590            * @return the matching journal content searchs
591            * @throws SystemException if a system exception occurred
592            */
593            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L(
594                    long groupId, boolean privateLayout, long layoutId)
595                    throws com.liferay.portal.kernel.exception.SystemException {
596                    return getPersistence().findByG_P_L(groupId, privateLayout, layoutId);
597            }
598    
599            /**
600            * Finds a range of all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
601            *
602            * <p>
603            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
604            * </p>
605            *
606            * @param groupId the group ID to search with
607            * @param privateLayout the private layout to search with
608            * @param layoutId the layout ID to search with
609            * @param start the lower bound of the range of journal content searchs to return
610            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
611            * @return the range of matching journal content searchs
612            * @throws SystemException if a system exception occurred
613            */
614            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L(
615                    long groupId, boolean privateLayout, long layoutId, int start, int end)
616                    throws com.liferay.portal.kernel.exception.SystemException {
617                    return getPersistence()
618                                       .findByG_P_L(groupId, privateLayout, layoutId, start, end);
619            }
620    
621            /**
622            * Finds an ordered range of all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
623            *
624            * <p>
625            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
626            * </p>
627            *
628            * @param groupId the group ID to search with
629            * @param privateLayout the private layout to search with
630            * @param layoutId the layout ID to search with
631            * @param start the lower bound of the range of journal content searchs to return
632            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
633            * @param orderByComparator the comparator to order the results by
634            * @return the ordered range of matching journal content searchs
635            * @throws SystemException if a system exception occurred
636            */
637            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L(
638                    long groupId, boolean privateLayout, long layoutId, int start, int end,
639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
640                    throws com.liferay.portal.kernel.exception.SystemException {
641                    return getPersistence()
642                                       .findByG_P_L(groupId, privateLayout, layoutId, start, end,
643                            orderByComparator);
644            }
645    
646            /**
647            * Finds the first journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
648            *
649            * <p>
650            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
651            * </p>
652            *
653            * @param groupId the group ID to search with
654            * @param privateLayout the private layout to search with
655            * @param layoutId the layout ID to search with
656            * @param orderByComparator the comparator to order the set by
657            * @return the first matching journal content search
658            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
659            * @throws SystemException if a system exception occurred
660            */
661            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_First(
662                    long groupId, boolean privateLayout, long layoutId,
663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
664                    throws com.liferay.portal.kernel.exception.SystemException,
665                            com.liferay.portlet.journal.NoSuchContentSearchException {
666                    return getPersistence()
667                                       .findByG_P_L_First(groupId, privateLayout, layoutId,
668                            orderByComparator);
669            }
670    
671            /**
672            * Finds the last journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
673            *
674            * <p>
675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
676            * </p>
677            *
678            * @param groupId the group ID to search with
679            * @param privateLayout the private layout to search with
680            * @param layoutId the layout ID to search with
681            * @param orderByComparator the comparator to order the set by
682            * @return the last matching journal content search
683            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
684            * @throws SystemException if a system exception occurred
685            */
686            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_Last(
687                    long groupId, boolean privateLayout, long layoutId,
688                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
689                    throws com.liferay.portal.kernel.exception.SystemException,
690                            com.liferay.portlet.journal.NoSuchContentSearchException {
691                    return getPersistence()
692                                       .findByG_P_L_Last(groupId, privateLayout, layoutId,
693                            orderByComparator);
694            }
695    
696            /**
697            * Finds the journal content searchs before and after the current journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
698            *
699            * <p>
700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
701            * </p>
702            *
703            * @param contentSearchId the primary key of the current journal content search
704            * @param groupId the group ID to search with
705            * @param privateLayout the private layout to search with
706            * @param layoutId the layout ID to search with
707            * @param orderByComparator the comparator to order the set by
708            * @return the previous, current, and next journal content search
709            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
710            * @throws SystemException if a system exception occurred
711            */
712            public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_L_PrevAndNext(
713                    long contentSearchId, long groupId, boolean privateLayout,
714                    long layoutId,
715                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
716                    throws com.liferay.portal.kernel.exception.SystemException,
717                            com.liferay.portlet.journal.NoSuchContentSearchException {
718                    return getPersistence()
719                                       .findByG_P_L_PrevAndNext(contentSearchId, groupId,
720                            privateLayout, layoutId, orderByComparator);
721            }
722    
723            /**
724            * Finds all the journal content searchs where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
725            *
726            * @param groupId the group ID to search with
727            * @param privateLayout the private layout to search with
728            * @param articleId the article ID to search with
729            * @return the matching journal content searchs
730            * @throws SystemException if a system exception occurred
731            */
732            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A(
733                    long groupId, boolean privateLayout, java.lang.String articleId)
734                    throws com.liferay.portal.kernel.exception.SystemException {
735                    return getPersistence().findByG_P_A(groupId, privateLayout, articleId);
736            }
737    
738            /**
739            * Finds a range of all the journal content searchs where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
740            *
741            * <p>
742            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
743            * </p>
744            *
745            * @param groupId the group ID to search with
746            * @param privateLayout the private layout to search with
747            * @param articleId the article ID to search with
748            * @param start the lower bound of the range of journal content searchs to return
749            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
750            * @return the range of matching journal content searchs
751            * @throws SystemException if a system exception occurred
752            */
753            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A(
754                    long groupId, boolean privateLayout, java.lang.String articleId,
755                    int start, int end)
756                    throws com.liferay.portal.kernel.exception.SystemException {
757                    return getPersistence()
758                                       .findByG_P_A(groupId, privateLayout, articleId, start, end);
759            }
760    
761            /**
762            * Finds an ordered range of all the journal content searchs where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
763            *
764            * <p>
765            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
766            * </p>
767            *
768            * @param groupId the group ID to search with
769            * @param privateLayout the private layout to search with
770            * @param articleId the article ID to search with
771            * @param start the lower bound of the range of journal content searchs to return
772            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
773            * @param orderByComparator the comparator to order the results by
774            * @return the ordered range of matching journal content searchs
775            * @throws SystemException if a system exception occurred
776            */
777            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_A(
778                    long groupId, boolean privateLayout, java.lang.String articleId,
779                    int start, int end,
780                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
781                    throws com.liferay.portal.kernel.exception.SystemException {
782                    return getPersistence()
783                                       .findByG_P_A(groupId, privateLayout, articleId, start, end,
784                            orderByComparator);
785            }
786    
787            /**
788            * Finds the first journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
789            *
790            * <p>
791            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
792            * </p>
793            *
794            * @param groupId the group ID to search with
795            * @param privateLayout the private layout to search with
796            * @param articleId the article ID to search with
797            * @param orderByComparator the comparator to order the set by
798            * @return the first matching journal content search
799            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
800            * @throws SystemException if a system exception occurred
801            */
802            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_A_First(
803                    long groupId, boolean privateLayout, java.lang.String articleId,
804                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
805                    throws com.liferay.portal.kernel.exception.SystemException,
806                            com.liferay.portlet.journal.NoSuchContentSearchException {
807                    return getPersistence()
808                                       .findByG_P_A_First(groupId, privateLayout, articleId,
809                            orderByComparator);
810            }
811    
812            /**
813            * Finds the last journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
814            *
815            * <p>
816            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
817            * </p>
818            *
819            * @param groupId the group ID to search with
820            * @param privateLayout the private layout to search with
821            * @param articleId the article ID to search with
822            * @param orderByComparator the comparator to order the set by
823            * @return the last matching journal content search
824            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
825            * @throws SystemException if a system exception occurred
826            */
827            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_A_Last(
828                    long groupId, boolean privateLayout, java.lang.String articleId,
829                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
830                    throws com.liferay.portal.kernel.exception.SystemException,
831                            com.liferay.portlet.journal.NoSuchContentSearchException {
832                    return getPersistence()
833                                       .findByG_P_A_Last(groupId, privateLayout, articleId,
834                            orderByComparator);
835            }
836    
837            /**
838            * Finds the journal content searchs before and after the current journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
839            *
840            * <p>
841            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
842            * </p>
843            *
844            * @param contentSearchId the primary key of the current journal content search
845            * @param groupId the group ID to search with
846            * @param privateLayout the private layout to search with
847            * @param articleId the article ID to search with
848            * @param orderByComparator the comparator to order the set by
849            * @return the previous, current, and next journal content search
850            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
851            * @throws SystemException if a system exception occurred
852            */
853            public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_A_PrevAndNext(
854                    long contentSearchId, long groupId, boolean privateLayout,
855                    java.lang.String articleId,
856                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
857                    throws com.liferay.portal.kernel.exception.SystemException,
858                            com.liferay.portlet.journal.NoSuchContentSearchException {
859                    return getPersistence()
860                                       .findByG_P_A_PrevAndNext(contentSearchId, groupId,
861                            privateLayout, articleId, orderByComparator);
862            }
863    
864            /**
865            * Finds all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
866            *
867            * @param groupId the group ID to search with
868            * @param privateLayout the private layout to search with
869            * @param layoutId the layout ID to search with
870            * @param portletId the portlet ID to search with
871            * @return the matching journal content searchs
872            * @throws SystemException if a system exception occurred
873            */
874            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P(
875                    long groupId, boolean privateLayout, long layoutId,
876                    java.lang.String portletId)
877                    throws com.liferay.portal.kernel.exception.SystemException {
878                    return getPersistence()
879                                       .findByG_P_L_P(groupId, privateLayout, layoutId, portletId);
880            }
881    
882            /**
883            * Finds a range of all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
884            *
885            * <p>
886            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
887            * </p>
888            *
889            * @param groupId the group ID to search with
890            * @param privateLayout the private layout to search with
891            * @param layoutId the layout ID to search with
892            * @param portletId the portlet ID to search with
893            * @param start the lower bound of the range of journal content searchs to return
894            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
895            * @return the range of matching journal content searchs
896            * @throws SystemException if a system exception occurred
897            */
898            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P(
899                    long groupId, boolean privateLayout, long layoutId,
900                    java.lang.String portletId, int start, int end)
901                    throws com.liferay.portal.kernel.exception.SystemException {
902                    return getPersistence()
903                                       .findByG_P_L_P(groupId, privateLayout, layoutId, portletId,
904                            start, end);
905            }
906    
907            /**
908            * Finds an ordered range of all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
909            *
910            * <p>
911            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
912            * </p>
913            *
914            * @param groupId the group ID to search with
915            * @param privateLayout the private layout to search with
916            * @param layoutId the layout ID to search with
917            * @param portletId the portlet ID to search with
918            * @param start the lower bound of the range of journal content searchs to return
919            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
920            * @param orderByComparator the comparator to order the results by
921            * @return the ordered range of matching journal content searchs
922            * @throws SystemException if a system exception occurred
923            */
924            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findByG_P_L_P(
925                    long groupId, boolean privateLayout, long layoutId,
926                    java.lang.String portletId, int start, int end,
927                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
928                    throws com.liferay.portal.kernel.exception.SystemException {
929                    return getPersistence()
930                                       .findByG_P_L_P(groupId, privateLayout, layoutId, portletId,
931                            start, end, orderByComparator);
932            }
933    
934            /**
935            * Finds the first journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
936            *
937            * <p>
938            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
939            * </p>
940            *
941            * @param groupId the group ID to search with
942            * @param privateLayout the private layout to search with
943            * @param layoutId the layout ID to search with
944            * @param portletId the portlet ID to search with
945            * @param orderByComparator the comparator to order the set by
946            * @return the first matching journal content search
947            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
948            * @throws SystemException if a system exception occurred
949            */
950            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_First(
951                    long groupId, boolean privateLayout, long layoutId,
952                    java.lang.String portletId,
953                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
954                    throws com.liferay.portal.kernel.exception.SystemException,
955                            com.liferay.portlet.journal.NoSuchContentSearchException {
956                    return getPersistence()
957                                       .findByG_P_L_P_First(groupId, privateLayout, layoutId,
958                            portletId, orderByComparator);
959            }
960    
961            /**
962            * Finds the last journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
963            *
964            * <p>
965            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
966            * </p>
967            *
968            * @param groupId the group ID to search with
969            * @param privateLayout the private layout to search with
970            * @param layoutId the layout ID to search with
971            * @param portletId the portlet ID to search with
972            * @param orderByComparator the comparator to order the set by
973            * @return the last matching journal content search
974            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
975            * @throws SystemException if a system exception occurred
976            */
977            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_Last(
978                    long groupId, boolean privateLayout, long layoutId,
979                    java.lang.String portletId,
980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
981                    throws com.liferay.portal.kernel.exception.SystemException,
982                            com.liferay.portlet.journal.NoSuchContentSearchException {
983                    return getPersistence()
984                                       .findByG_P_L_P_Last(groupId, privateLayout, layoutId,
985                            portletId, orderByComparator);
986            }
987    
988            /**
989            * Finds the journal content searchs before and after the current journal content search in the ordered set where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
990            *
991            * <p>
992            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
993            * </p>
994            *
995            * @param contentSearchId the primary key of the current journal content search
996            * @param groupId the group ID to search with
997            * @param privateLayout the private layout to search with
998            * @param layoutId the layout ID to search with
999            * @param portletId the portlet ID to search with
1000            * @param orderByComparator the comparator to order the set by
1001            * @return the previous, current, and next journal content search
1002            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a journal content search with the primary key could not be found
1003            * @throws SystemException if a system exception occurred
1004            */
1005            public static com.liferay.portlet.journal.model.JournalContentSearch[] findByG_P_L_P_PrevAndNext(
1006                    long contentSearchId, long groupId, boolean privateLayout,
1007                    long layoutId, java.lang.String portletId,
1008                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1009                    throws com.liferay.portal.kernel.exception.SystemException,
1010                            com.liferay.portlet.journal.NoSuchContentSearchException {
1011                    return getPersistence()
1012                                       .findByG_P_L_P_PrevAndNext(contentSearchId, groupId,
1013                            privateLayout, layoutId, portletId, orderByComparator);
1014            }
1015    
1016            /**
1017            * Finds the journal content search where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63; and articleId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchContentSearchException} if it could not be found.
1018            *
1019            * @param groupId the group ID to search with
1020            * @param privateLayout the private layout to search with
1021            * @param layoutId the layout ID to search with
1022            * @param portletId the portlet ID to search with
1023            * @param articleId the article ID to search with
1024            * @return the matching journal content search
1025            * @throws com.liferay.portlet.journal.NoSuchContentSearchException if a matching journal content search could not be found
1026            * @throws SystemException if a system exception occurred
1027            */
1028            public static com.liferay.portlet.journal.model.JournalContentSearch findByG_P_L_P_A(
1029                    long groupId, boolean privateLayout, long layoutId,
1030                    java.lang.String portletId, java.lang.String articleId)
1031                    throws com.liferay.portal.kernel.exception.SystemException,
1032                            com.liferay.portlet.journal.NoSuchContentSearchException {
1033                    return getPersistence()
1034                                       .findByG_P_L_P_A(groupId, privateLayout, layoutId,
1035                            portletId, articleId);
1036            }
1037    
1038            /**
1039            * Finds the journal content search where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63; and articleId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1040            *
1041            * @param groupId the group ID to search with
1042            * @param privateLayout the private layout to search with
1043            * @param layoutId the layout ID to search with
1044            * @param portletId the portlet ID to search with
1045            * @param articleId the article ID to search with
1046            * @return the matching journal content search, or <code>null</code> if a matching journal content search could not be found
1047            * @throws SystemException if a system exception occurred
1048            */
1049            public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_A(
1050                    long groupId, boolean privateLayout, long layoutId,
1051                    java.lang.String portletId, java.lang.String articleId)
1052                    throws com.liferay.portal.kernel.exception.SystemException {
1053                    return getPersistence()
1054                                       .fetchByG_P_L_P_A(groupId, privateLayout, layoutId,
1055                            portletId, articleId);
1056            }
1057    
1058            /**
1059            * Finds the journal content search where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63; and articleId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1060            *
1061            * @param groupId the group ID to search with
1062            * @param privateLayout the private layout to search with
1063            * @param layoutId the layout ID to search with
1064            * @param portletId the portlet ID to search with
1065            * @param articleId the article ID to search with
1066            * @return the matching journal content search, or <code>null</code> if a matching journal content search could not be found
1067            * @throws SystemException if a system exception occurred
1068            */
1069            public static com.liferay.portlet.journal.model.JournalContentSearch fetchByG_P_L_P_A(
1070                    long groupId, boolean privateLayout, long layoutId,
1071                    java.lang.String portletId, java.lang.String articleId,
1072                    boolean retrieveFromCache)
1073                    throws com.liferay.portal.kernel.exception.SystemException {
1074                    return getPersistence()
1075                                       .fetchByG_P_L_P_A(groupId, privateLayout, layoutId,
1076                            portletId, articleId, retrieveFromCache);
1077            }
1078    
1079            /**
1080            * Finds all the journal content searchs.
1081            *
1082            * @return the journal content searchs
1083            * @throws SystemException if a system exception occurred
1084            */
1085            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll()
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    return getPersistence().findAll();
1088            }
1089    
1090            /**
1091            * Finds a range of all the journal content searchs.
1092            *
1093            * <p>
1094            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1095            * </p>
1096            *
1097            * @param start the lower bound of the range of journal content searchs to return
1098            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
1099            * @return the range of journal content searchs
1100            * @throws SystemException if a system exception occurred
1101            */
1102            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll(
1103                    int start, int end)
1104                    throws com.liferay.portal.kernel.exception.SystemException {
1105                    return getPersistence().findAll(start, end);
1106            }
1107    
1108            /**
1109            * Finds an ordered range of all the journal content searchs.
1110            *
1111            * <p>
1112            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1113            * </p>
1114            *
1115            * @param start the lower bound of the range of journal content searchs to return
1116            * @param end the upper bound of the range of journal content searchs to return (not inclusive)
1117            * @param orderByComparator the comparator to order the results by
1118            * @return the ordered range of journal content searchs
1119            * @throws SystemException if a system exception occurred
1120            */
1121            public static java.util.List<com.liferay.portlet.journal.model.JournalContentSearch> findAll(
1122                    int start, int end,
1123                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1124                    throws com.liferay.portal.kernel.exception.SystemException {
1125                    return getPersistence().findAll(start, end, orderByComparator);
1126            }
1127    
1128            /**
1129            * Removes all the journal content searchs where articleId = &#63; from the database.
1130            *
1131            * @param articleId the article ID to search with
1132            * @throws SystemException if a system exception occurred
1133            */
1134            public static void removeByArticleId(java.lang.String articleId)
1135                    throws com.liferay.portal.kernel.exception.SystemException {
1136                    getPersistence().removeByArticleId(articleId);
1137            }
1138    
1139            /**
1140            * Removes all the journal content searchs where groupId = &#63; and privateLayout = &#63; from the database.
1141            *
1142            * @param groupId the group ID to search with
1143            * @param privateLayout the private layout to search with
1144            * @throws SystemException if a system exception occurred
1145            */
1146            public static void removeByG_P(long groupId, boolean privateLayout)
1147                    throws com.liferay.portal.kernel.exception.SystemException {
1148                    getPersistence().removeByG_P(groupId, privateLayout);
1149            }
1150    
1151            /**
1152            * Removes all the journal content searchs where groupId = &#63; and articleId = &#63; from the database.
1153            *
1154            * @param groupId the group ID to search with
1155            * @param articleId the article ID to search with
1156            * @throws SystemException if a system exception occurred
1157            */
1158            public static void removeByG_A(long groupId, java.lang.String articleId)
1159                    throws com.liferay.portal.kernel.exception.SystemException {
1160                    getPersistence().removeByG_A(groupId, articleId);
1161            }
1162    
1163            /**
1164            * Removes all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; from the database.
1165            *
1166            * @param groupId the group ID to search with
1167            * @param privateLayout the private layout to search with
1168            * @param layoutId the layout ID to search with
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static void removeByG_P_L(long groupId, boolean privateLayout,
1172                    long layoutId)
1173                    throws com.liferay.portal.kernel.exception.SystemException {
1174                    getPersistence().removeByG_P_L(groupId, privateLayout, layoutId);
1175            }
1176    
1177            /**
1178            * Removes all the journal content searchs where groupId = &#63; and privateLayout = &#63; and articleId = &#63; from the database.
1179            *
1180            * @param groupId the group ID to search with
1181            * @param privateLayout the private layout to search with
1182            * @param articleId the article ID to search with
1183            * @throws SystemException if a system exception occurred
1184            */
1185            public static void removeByG_P_A(long groupId, boolean privateLayout,
1186                    java.lang.String articleId)
1187                    throws com.liferay.portal.kernel.exception.SystemException {
1188                    getPersistence().removeByG_P_A(groupId, privateLayout, articleId);
1189            }
1190    
1191            /**
1192            * Removes all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63; from the database.
1193            *
1194            * @param groupId the group ID to search with
1195            * @param privateLayout the private layout to search with
1196            * @param layoutId the layout ID to search with
1197            * @param portletId the portlet ID to search with
1198            * @throws SystemException if a system exception occurred
1199            */
1200            public static void removeByG_P_L_P(long groupId, boolean privateLayout,
1201                    long layoutId, java.lang.String portletId)
1202                    throws com.liferay.portal.kernel.exception.SystemException {
1203                    getPersistence()
1204                            .removeByG_P_L_P(groupId, privateLayout, layoutId, portletId);
1205            }
1206    
1207            /**
1208            * Removes the journal content search where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63; and articleId = &#63; from the database.
1209            *
1210            * @param groupId the group ID to search with
1211            * @param privateLayout the private layout to search with
1212            * @param layoutId the layout ID to search with
1213            * @param portletId the portlet ID to search with
1214            * @param articleId the article ID to search with
1215            * @throws SystemException if a system exception occurred
1216            */
1217            public static void removeByG_P_L_P_A(long groupId, boolean privateLayout,
1218                    long layoutId, java.lang.String portletId, java.lang.String articleId)
1219                    throws com.liferay.portal.kernel.exception.SystemException,
1220                            com.liferay.portlet.journal.NoSuchContentSearchException {
1221                    getPersistence()
1222                            .removeByG_P_L_P_A(groupId, privateLayout, layoutId, portletId,
1223                            articleId);
1224            }
1225    
1226            /**
1227            * Removes all the journal content searchs from the database.
1228            *
1229            * @throws SystemException if a system exception occurred
1230            */
1231            public static void removeAll()
1232                    throws com.liferay.portal.kernel.exception.SystemException {
1233                    getPersistence().removeAll();
1234            }
1235    
1236            /**
1237            * Counts all the journal content searchs where articleId = &#63;.
1238            *
1239            * @param articleId the article ID to search with
1240            * @return the number of matching journal content searchs
1241            * @throws SystemException if a system exception occurred
1242            */
1243            public static int countByArticleId(java.lang.String articleId)
1244                    throws com.liferay.portal.kernel.exception.SystemException {
1245                    return getPersistence().countByArticleId(articleId);
1246            }
1247    
1248            /**
1249            * Counts all the journal content searchs where groupId = &#63; and privateLayout = &#63;.
1250            *
1251            * @param groupId the group ID to search with
1252            * @param privateLayout the private layout to search with
1253            * @return the number of matching journal content searchs
1254            * @throws SystemException if a system exception occurred
1255            */
1256            public static int countByG_P(long groupId, boolean privateLayout)
1257                    throws com.liferay.portal.kernel.exception.SystemException {
1258                    return getPersistence().countByG_P(groupId, privateLayout);
1259            }
1260    
1261            /**
1262            * Counts all the journal content searchs where groupId = &#63; and articleId = &#63;.
1263            *
1264            * @param groupId the group ID to search with
1265            * @param articleId the article ID to search with
1266            * @return the number of matching journal content searchs
1267            * @throws SystemException if a system exception occurred
1268            */
1269            public static int countByG_A(long groupId, java.lang.String articleId)
1270                    throws com.liferay.portal.kernel.exception.SystemException {
1271                    return getPersistence().countByG_A(groupId, articleId);
1272            }
1273    
1274            /**
1275            * Counts all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
1276            *
1277            * @param groupId the group ID to search with
1278            * @param privateLayout the private layout to search with
1279            * @param layoutId the layout ID to search with
1280            * @return the number of matching journal content searchs
1281            * @throws SystemException if a system exception occurred
1282            */
1283            public static int countByG_P_L(long groupId, boolean privateLayout,
1284                    long layoutId)
1285                    throws com.liferay.portal.kernel.exception.SystemException {
1286                    return getPersistence().countByG_P_L(groupId, privateLayout, layoutId);
1287            }
1288    
1289            /**
1290            * Counts all the journal content searchs where groupId = &#63; and privateLayout = &#63; and articleId = &#63;.
1291            *
1292            * @param groupId the group ID to search with
1293            * @param privateLayout the private layout to search with
1294            * @param articleId the article ID to search with
1295            * @return the number of matching journal content searchs
1296            * @throws SystemException if a system exception occurred
1297            */
1298            public static int countByG_P_A(long groupId, boolean privateLayout,
1299                    java.lang.String articleId)
1300                    throws com.liferay.portal.kernel.exception.SystemException {
1301                    return getPersistence().countByG_P_A(groupId, privateLayout, articleId);
1302            }
1303    
1304            /**
1305            * Counts all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63;.
1306            *
1307            * @param groupId the group ID to search with
1308            * @param privateLayout the private layout to search with
1309            * @param layoutId the layout ID to search with
1310            * @param portletId the portlet ID to search with
1311            * @return the number of matching journal content searchs
1312            * @throws SystemException if a system exception occurred
1313            */
1314            public static int countByG_P_L_P(long groupId, boolean privateLayout,
1315                    long layoutId, java.lang.String portletId)
1316                    throws com.liferay.portal.kernel.exception.SystemException {
1317                    return getPersistence()
1318                                       .countByG_P_L_P(groupId, privateLayout, layoutId, portletId);
1319            }
1320    
1321            /**
1322            * Counts all the journal content searchs where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; and portletId = &#63; and articleId = &#63;.
1323            *
1324            * @param groupId the group ID to search with
1325            * @param privateLayout the private layout to search with
1326            * @param layoutId the layout ID to search with
1327            * @param portletId the portlet ID to search with
1328            * @param articleId the article ID to search with
1329            * @return the number of matching journal content searchs
1330            * @throws SystemException if a system exception occurred
1331            */
1332            public static int countByG_P_L_P_A(long groupId, boolean privateLayout,
1333                    long layoutId, java.lang.String portletId, java.lang.String articleId)
1334                    throws com.liferay.portal.kernel.exception.SystemException {
1335                    return getPersistence()
1336                                       .countByG_P_L_P_A(groupId, privateLayout, layoutId,
1337                            portletId, articleId);
1338            }
1339    
1340            /**
1341            * Counts all the journal content searchs.
1342            *
1343            * @return the number of journal content searchs
1344            * @throws SystemException if a system exception occurred
1345            */
1346            public static int countAll()
1347                    throws com.liferay.portal.kernel.exception.SystemException {
1348                    return getPersistence().countAll();
1349            }
1350    
1351            public static JournalContentSearchPersistence getPersistence() {
1352                    if (_persistence == null) {
1353                            _persistence = (JournalContentSearchPersistence)PortalBeanLocatorUtil.locate(JournalContentSearchPersistence.class.getName());
1354    
1355                            ReferenceRegistry.registerReference(JournalContentSearchUtil.class,
1356                                    "_persistence");
1357                    }
1358    
1359                    return _persistence;
1360            }
1361    
1362            public void setPersistence(JournalContentSearchPersistence persistence) {
1363                    _persistence = persistence;
1364    
1365                    ReferenceRegistry.registerReference(JournalContentSearchUtil.class,
1366                            "_persistence");
1367            }
1368    
1369            private static JournalContentSearchPersistence _persistence;
1370    }