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