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