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.JournalArticle;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} 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 JournalArticlePersistence
038     * @see JournalArticlePersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class JournalArticleUtil {
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(JournalArticle journalArticle) {
060                    getPersistence().clearCache(journalArticle);
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<JournalArticle> 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<JournalArticle> 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<JournalArticle> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<JournalArticle> 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 JournalArticle update(JournalArticle journalArticle) {
101                    return getPersistence().update(journalArticle);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static JournalArticle update(JournalArticle journalArticle,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(journalArticle, serviceContext);
110            }
111    
112            /**
113            * Returns all the journal articles where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching journal articles
117            */
118            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
119                    java.lang.String uuid) {
120                    return getPersistence().findByUuid(uuid);
121            }
122    
123            /**
124            * Returns a range of all the journal articles where uuid = &#63;.
125            *
126            * <p>
127            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
128            * </p>
129            *
130            * @param uuid the uuid
131            * @param start the lower bound of the range of journal articles
132            * @param end the upper bound of the range of journal articles (not inclusive)
133            * @return the range of matching journal articles
134            */
135            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
136                    java.lang.String uuid, int start, int end) {
137                    return getPersistence().findByUuid(uuid, start, end);
138            }
139    
140            /**
141            * Returns an ordered range of all the journal articles where uuid = &#63;.
142            *
143            * <p>
144            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
145            * </p>
146            *
147            * @param uuid the uuid
148            * @param start the lower bound of the range of journal articles
149            * @param end the upper bound of the range of journal articles (not inclusive)
150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
151            * @return the ordered range of matching journal articles
152            */
153            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
154                    java.lang.String uuid, int start, int end,
155                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
156                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
157            }
158    
159            /**
160            * Returns the first journal article in the ordered set where uuid = &#63;.
161            *
162            * @param uuid the uuid
163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
164            * @return the first matching journal article
165            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
166            */
167            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
168                    java.lang.String uuid,
169                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
170                    throws com.liferay.portlet.journal.NoSuchArticleException {
171                    return getPersistence().findByUuid_First(uuid, orderByComparator);
172            }
173    
174            /**
175            * Returns the first journal article in the ordered set where uuid = &#63;.
176            *
177            * @param uuid the uuid
178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
179            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
180            */
181            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First(
182                    java.lang.String uuid,
183                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
184                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
185            }
186    
187            /**
188            * Returns the last journal article in the ordered set where uuid = &#63;.
189            *
190            * @param uuid the uuid
191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
192            * @return the last matching journal article
193            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
194            */
195            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
196                    java.lang.String uuid,
197                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
198                    throws com.liferay.portlet.journal.NoSuchArticleException {
199                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
200            }
201    
202            /**
203            * Returns the last journal article in the ordered set where uuid = &#63;.
204            *
205            * @param uuid the uuid
206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
207            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
208            */
209            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last(
210                    java.lang.String uuid,
211                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
212                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
217            *
218            * @param id the primary key of the current journal article
219            * @param uuid the uuid
220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
221            * @return the previous, current, and next journal article
222            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
223            */
224            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
225                    long id, java.lang.String uuid,
226                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
227                    throws com.liferay.portlet.journal.NoSuchArticleException {
228                    return getPersistence()
229                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
230            }
231    
232            /**
233            * Removes all the journal articles where uuid = &#63; from the database.
234            *
235            * @param uuid the uuid
236            */
237            public static void removeByUuid(java.lang.String uuid) {
238                    getPersistence().removeByUuid(uuid);
239            }
240    
241            /**
242            * Returns the number of journal articles where uuid = &#63;.
243            *
244            * @param uuid the uuid
245            * @return the number of matching journal articles
246            */
247            public static int countByUuid(java.lang.String uuid) {
248                    return getPersistence().countByUuid(uuid);
249            }
250    
251            /**
252            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
253            *
254            * @param uuid the uuid
255            * @param groupId the group ID
256            * @return the matching journal article
257            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
258            */
259            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
260                    java.lang.String uuid, long groupId)
261                    throws com.liferay.portlet.journal.NoSuchArticleException {
262                    return getPersistence().findByUUID_G(uuid, groupId);
263            }
264    
265            /**
266            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
267            *
268            * @param uuid the uuid
269            * @param groupId the group ID
270            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
271            */
272            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
273                    java.lang.String uuid, long groupId) {
274                    return getPersistence().fetchByUUID_G(uuid, groupId);
275            }
276    
277            /**
278            * Returns the journal article where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
279            *
280            * @param uuid the uuid
281            * @param groupId the group ID
282            * @param retrieveFromCache whether to use the finder cache
283            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
284            */
285            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
286                    java.lang.String uuid, long groupId, boolean retrieveFromCache) {
287                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
288            }
289    
290            /**
291            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
292            *
293            * @param uuid the uuid
294            * @param groupId the group ID
295            * @return the journal article that was removed
296            */
297            public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G(
298                    java.lang.String uuid, long groupId)
299                    throws com.liferay.portlet.journal.NoSuchArticleException {
300                    return getPersistence().removeByUUID_G(uuid, groupId);
301            }
302    
303            /**
304            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
305            *
306            * @param uuid the uuid
307            * @param groupId the group ID
308            * @return the number of matching journal articles
309            */
310            public static int countByUUID_G(java.lang.String uuid, long groupId) {
311                    return getPersistence().countByUUID_G(uuid, groupId);
312            }
313    
314            /**
315            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
316            *
317            * @param uuid the uuid
318            * @param companyId the company ID
319            * @return the matching journal articles
320            */
321            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
322                    java.lang.String uuid, long companyId) {
323                    return getPersistence().findByUuid_C(uuid, companyId);
324            }
325    
326            /**
327            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
328            *
329            * <p>
330            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
331            * </p>
332            *
333            * @param uuid the uuid
334            * @param companyId the company ID
335            * @param start the lower bound of the range of journal articles
336            * @param end the upper bound of the range of journal articles (not inclusive)
337            * @return the range of matching journal articles
338            */
339            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
340                    java.lang.String uuid, long companyId, int start, int end) {
341                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
342            }
343    
344            /**
345            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
346            *
347            * <p>
348            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
349            * </p>
350            *
351            * @param uuid the uuid
352            * @param companyId the company ID
353            * @param start the lower bound of the range of journal articles
354            * @param end the upper bound of the range of journal articles (not inclusive)
355            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
356            * @return the ordered range of matching journal articles
357            */
358            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C(
359                    java.lang.String uuid, long companyId, int start, int end,
360                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
361                    return getPersistence()
362                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
363            }
364    
365            /**
366            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
367            *
368            * @param uuid the uuid
369            * @param companyId the company ID
370            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
371            * @return the first matching journal article
372            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
373            */
374            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First(
375                    java.lang.String uuid, long companyId,
376                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
377                    throws com.liferay.portlet.journal.NoSuchArticleException {
378                    return getPersistence()
379                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
380            }
381    
382            /**
383            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
388            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
389            */
390            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First(
391                    java.lang.String uuid, long companyId,
392                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
393                    return getPersistence()
394                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
395            }
396    
397            /**
398            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
399            *
400            * @param uuid the uuid
401            * @param companyId the company ID
402            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
403            * @return the last matching journal article
404            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
405            */
406            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last(
407                    java.lang.String uuid, long companyId,
408                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
409                    throws com.liferay.portlet.journal.NoSuchArticleException {
410                    return getPersistence()
411                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
412            }
413    
414            /**
415            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
416            *
417            * @param uuid the uuid
418            * @param companyId the company ID
419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
420            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
421            */
422            public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last(
423                    java.lang.String uuid, long companyId,
424                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
425                    return getPersistence()
426                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
427            }
428    
429            /**
430            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
431            *
432            * @param id the primary key of the current journal article
433            * @param uuid the uuid
434            * @param companyId the company ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the previous, current, and next journal article
437            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
438            */
439            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext(
440                    long id, java.lang.String uuid, long companyId,
441                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
442                    throws com.liferay.portlet.journal.NoSuchArticleException {
443                    return getPersistence()
444                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
445                            orderByComparator);
446            }
447    
448            /**
449            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
450            *
451            * @param uuid the uuid
452            * @param companyId the company ID
453            */
454            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
455                    getPersistence().removeByUuid_C(uuid, companyId);
456            }
457    
458            /**
459            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
460            *
461            * @param uuid the uuid
462            * @param companyId the company ID
463            * @return the number of matching journal articles
464            */
465            public static int countByUuid_C(java.lang.String uuid, long companyId) {
466                    return getPersistence().countByUuid_C(uuid, companyId);
467            }
468    
469            /**
470            * Returns all the journal articles where resourcePrimKey = &#63;.
471            *
472            * @param resourcePrimKey the resource prim key
473            * @return the matching journal articles
474            */
475            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
476                    long resourcePrimKey) {
477                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
478            }
479    
480            /**
481            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
482            *
483            * <p>
484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
485            * </p>
486            *
487            * @param resourcePrimKey the resource prim key
488            * @param start the lower bound of the range of journal articles
489            * @param end the upper bound of the range of journal articles (not inclusive)
490            * @return the range of matching journal articles
491            */
492            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
493                    long resourcePrimKey, int start, int end) {
494                    return getPersistence()
495                                       .findByResourcePrimKey(resourcePrimKey, start, end);
496            }
497    
498            /**
499            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
500            *
501            * <p>
502            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
503            * </p>
504            *
505            * @param resourcePrimKey the resource prim key
506            * @param start the lower bound of the range of journal articles
507            * @param end the upper bound of the range of journal articles (not inclusive)
508            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
509            * @return the ordered range of matching journal articles
510            */
511            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
512                    long resourcePrimKey, int start, int end,
513                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
514                    return getPersistence()
515                                       .findByResourcePrimKey(resourcePrimKey, start, end,
516                            orderByComparator);
517            }
518    
519            /**
520            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
521            *
522            * @param resourcePrimKey the resource prim key
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the first matching journal article
525            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
526            */
527            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
528                    long resourcePrimKey,
529                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
530                    throws com.liferay.portlet.journal.NoSuchArticleException {
531                    return getPersistence()
532                                       .findByResourcePrimKey_First(resourcePrimKey,
533                            orderByComparator);
534            }
535    
536            /**
537            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
538            *
539            * @param resourcePrimKey the resource prim key
540            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
541            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
542            */
543            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First(
544                    long resourcePrimKey,
545                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
546                    return getPersistence()
547                                       .fetchByResourcePrimKey_First(resourcePrimKey,
548                            orderByComparator);
549            }
550    
551            /**
552            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
553            *
554            * @param resourcePrimKey the resource prim key
555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
556            * @return the last matching journal article
557            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
558            */
559            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
560                    long resourcePrimKey,
561                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
562                    throws com.liferay.portlet.journal.NoSuchArticleException {
563                    return getPersistence()
564                                       .findByResourcePrimKey_Last(resourcePrimKey,
565                            orderByComparator);
566            }
567    
568            /**
569            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
570            *
571            * @param resourcePrimKey the resource prim key
572            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
573            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
574            */
575            public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last(
576                    long resourcePrimKey,
577                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
578                    return getPersistence()
579                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
580                            orderByComparator);
581            }
582    
583            /**
584            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
585            *
586            * @param id the primary key of the current journal article
587            * @param resourcePrimKey the resource prim key
588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
589            * @return the previous, current, and next journal article
590            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
591            */
592            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
593                    long id, long resourcePrimKey,
594                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
595                    throws com.liferay.portlet.journal.NoSuchArticleException {
596                    return getPersistence()
597                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
598                            orderByComparator);
599            }
600    
601            /**
602            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
603            *
604            * @param resourcePrimKey the resource prim key
605            */
606            public static void removeByResourcePrimKey(long resourcePrimKey) {
607                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
608            }
609    
610            /**
611            * Returns the number of journal articles where resourcePrimKey = &#63;.
612            *
613            * @param resourcePrimKey the resource prim key
614            * @return the number of matching journal articles
615            */
616            public static int countByResourcePrimKey(long resourcePrimKey) {
617                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
618            }
619    
620            /**
621            * Returns all the journal articles where groupId = &#63;.
622            *
623            * @param groupId the group ID
624            * @return the matching journal articles
625            */
626            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
627                    long groupId) {
628                    return getPersistence().findByGroupId(groupId);
629            }
630    
631            /**
632            * Returns a range of all the journal articles where groupId = &#63;.
633            *
634            * <p>
635            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
636            * </p>
637            *
638            * @param groupId the group ID
639            * @param start the lower bound of the range of journal articles
640            * @param end the upper bound of the range of journal articles (not inclusive)
641            * @return the range of matching journal articles
642            */
643            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
644                    long groupId, int start, int end) {
645                    return getPersistence().findByGroupId(groupId, start, end);
646            }
647    
648            /**
649            * Returns an ordered range of all the journal articles where groupId = &#63;.
650            *
651            * <p>
652            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
653            * </p>
654            *
655            * @param groupId the group ID
656            * @param start the lower bound of the range of journal articles
657            * @param end the upper bound of the range of journal articles (not inclusive)
658            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
659            * @return the ordered range of matching journal articles
660            */
661            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
662                    long groupId, int start, int end,
663                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
664                    return getPersistence()
665                                       .findByGroupId(groupId, start, end, orderByComparator);
666            }
667    
668            /**
669            * Returns the first journal article in the ordered set where groupId = &#63;.
670            *
671            * @param groupId the group ID
672            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
673            * @return the first matching journal article
674            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
675            */
676            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
677                    long groupId,
678                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
679                    throws com.liferay.portlet.journal.NoSuchArticleException {
680                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
681            }
682    
683            /**
684            * Returns the first journal article in the ordered set where groupId = &#63;.
685            *
686            * @param groupId the group ID
687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
688            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
689            */
690            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First(
691                    long groupId,
692                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
693                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
694            }
695    
696            /**
697            * Returns the last journal article in the ordered set where groupId = &#63;.
698            *
699            * @param groupId the group ID
700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
701            * @return the last matching journal article
702            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
703            */
704            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
705                    long groupId,
706                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
707                    throws com.liferay.portlet.journal.NoSuchArticleException {
708                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
709            }
710    
711            /**
712            * Returns the last journal article in the ordered set where groupId = &#63;.
713            *
714            * @param groupId the group ID
715            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
716            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
717            */
718            public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last(
719                    long groupId,
720                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
721                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
722            }
723    
724            /**
725            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
726            *
727            * @param id the primary key of the current journal article
728            * @param groupId the group ID
729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
730            * @return the previous, current, and next journal article
731            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
732            */
733            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
734                    long id, long groupId,
735                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
736                    throws com.liferay.portlet.journal.NoSuchArticleException {
737                    return getPersistence()
738                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
739            }
740    
741            /**
742            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
743            *
744            * @param groupId the group ID
745            * @return the matching journal articles that the user has permission to view
746            */
747            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
748                    long groupId) {
749                    return getPersistence().filterFindByGroupId(groupId);
750            }
751    
752            /**
753            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
754            *
755            * <p>
756            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
757            * </p>
758            *
759            * @param groupId the group ID
760            * @param start the lower bound of the range of journal articles
761            * @param end the upper bound of the range of journal articles (not inclusive)
762            * @return the range of matching journal articles that the user has permission to view
763            */
764            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
765                    long groupId, int start, int end) {
766                    return getPersistence().filterFindByGroupId(groupId, start, end);
767            }
768    
769            /**
770            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
771            *
772            * <p>
773            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
774            * </p>
775            *
776            * @param groupId the group ID
777            * @param start the lower bound of the range of journal articles
778            * @param end the upper bound of the range of journal articles (not inclusive)
779            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
780            * @return the ordered range of matching journal articles that the user has permission to view
781            */
782            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
783                    long groupId, int start, int end,
784                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
785                    return getPersistence()
786                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
787            }
788    
789            /**
790            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63;.
791            *
792            * @param id the primary key of the current journal article
793            * @param groupId the group ID
794            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
795            * @return the previous, current, and next journal article
796            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
797            */
798            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
799                    long id, long groupId,
800                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
801                    throws com.liferay.portlet.journal.NoSuchArticleException {
802                    return getPersistence()
803                                       .filterFindByGroupId_PrevAndNext(id, groupId,
804                            orderByComparator);
805            }
806    
807            /**
808            * Removes all the journal articles where groupId = &#63; from the database.
809            *
810            * @param groupId the group ID
811            */
812            public static void removeByGroupId(long groupId) {
813                    getPersistence().removeByGroupId(groupId);
814            }
815    
816            /**
817            * Returns the number of journal articles where groupId = &#63;.
818            *
819            * @param groupId the group ID
820            * @return the number of matching journal articles
821            */
822            public static int countByGroupId(long groupId) {
823                    return getPersistence().countByGroupId(groupId);
824            }
825    
826            /**
827            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
828            *
829            * @param groupId the group ID
830            * @return the number of matching journal articles that the user has permission to view
831            */
832            public static int filterCountByGroupId(long groupId) {
833                    return getPersistence().filterCountByGroupId(groupId);
834            }
835    
836            /**
837            * Returns all the journal articles where companyId = &#63;.
838            *
839            * @param companyId the company ID
840            * @return the matching journal articles
841            */
842            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
843                    long companyId) {
844                    return getPersistence().findByCompanyId(companyId);
845            }
846    
847            /**
848            * Returns a range of all the journal articles where companyId = &#63;.
849            *
850            * <p>
851            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
852            * </p>
853            *
854            * @param companyId the company ID
855            * @param start the lower bound of the range of journal articles
856            * @param end the upper bound of the range of journal articles (not inclusive)
857            * @return the range of matching journal articles
858            */
859            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
860                    long companyId, int start, int end) {
861                    return getPersistence().findByCompanyId(companyId, start, end);
862            }
863    
864            /**
865            * Returns an ordered range of all the journal articles where companyId = &#63;.
866            *
867            * <p>
868            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
869            * </p>
870            *
871            * @param companyId the company ID
872            * @param start the lower bound of the range of journal articles
873            * @param end the upper bound of the range of journal articles (not inclusive)
874            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
875            * @return the ordered range of matching journal articles
876            */
877            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
878                    long companyId, int start, int end,
879                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
880                    return getPersistence()
881                                       .findByCompanyId(companyId, start, end, orderByComparator);
882            }
883    
884            /**
885            * Returns the first journal article in the ordered set where companyId = &#63;.
886            *
887            * @param companyId the company ID
888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
889            * @return the first matching journal article
890            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
891            */
892            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
893                    long companyId,
894                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
895                    throws com.liferay.portlet.journal.NoSuchArticleException {
896                    return getPersistence()
897                                       .findByCompanyId_First(companyId, orderByComparator);
898            }
899    
900            /**
901            * Returns the first journal article in the ordered set where companyId = &#63;.
902            *
903            * @param companyId the company ID
904            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
905            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
906            */
907            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First(
908                    long companyId,
909                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
910                    return getPersistence()
911                                       .fetchByCompanyId_First(companyId, orderByComparator);
912            }
913    
914            /**
915            * Returns the last journal article in the ordered set where companyId = &#63;.
916            *
917            * @param companyId the company ID
918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
919            * @return the last matching journal article
920            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
921            */
922            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
923                    long companyId,
924                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
925                    throws com.liferay.portlet.journal.NoSuchArticleException {
926                    return getPersistence()
927                                       .findByCompanyId_Last(companyId, orderByComparator);
928            }
929    
930            /**
931            * Returns the last journal article in the ordered set where companyId = &#63;.
932            *
933            * @param companyId the company ID
934            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
935            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
936            */
937            public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last(
938                    long companyId,
939                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
940                    return getPersistence()
941                                       .fetchByCompanyId_Last(companyId, orderByComparator);
942            }
943    
944            /**
945            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
946            *
947            * @param id the primary key of the current journal article
948            * @param companyId the company ID
949            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
950            * @return the previous, current, and next journal article
951            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
952            */
953            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
954                    long id, long companyId,
955                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
956                    throws com.liferay.portlet.journal.NoSuchArticleException {
957                    return getPersistence()
958                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
959            }
960    
961            /**
962            * Removes all the journal articles where companyId = &#63; from the database.
963            *
964            * @param companyId the company ID
965            */
966            public static void removeByCompanyId(long companyId) {
967                    getPersistence().removeByCompanyId(companyId);
968            }
969    
970            /**
971            * Returns the number of journal articles where companyId = &#63;.
972            *
973            * @param companyId the company ID
974            * @return the number of matching journal articles
975            */
976            public static int countByCompanyId(long companyId) {
977                    return getPersistence().countByCompanyId(companyId);
978            }
979    
980            /**
981            * Returns all the journal articles where structureId = &#63;.
982            *
983            * @param structureId the structure ID
984            * @return the matching journal articles
985            */
986            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
987                    java.lang.String structureId) {
988                    return getPersistence().findByStructureId(structureId);
989            }
990    
991            /**
992            * Returns a range of all the journal articles where structureId = &#63;.
993            *
994            * <p>
995            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
996            * </p>
997            *
998            * @param structureId the structure ID
999            * @param start the lower bound of the range of journal articles
1000            * @param end the upper bound of the range of journal articles (not inclusive)
1001            * @return the range of matching journal articles
1002            */
1003            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1004                    java.lang.String structureId, int start, int end) {
1005                    return getPersistence().findByStructureId(structureId, start, end);
1006            }
1007    
1008            /**
1009            * Returns an ordered range of all the journal articles where structureId = &#63;.
1010            *
1011            * <p>
1012            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1013            * </p>
1014            *
1015            * @param structureId the structure ID
1016            * @param start the lower bound of the range of journal articles
1017            * @param end the upper bound of the range of journal articles (not inclusive)
1018            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1019            * @return the ordered range of matching journal articles
1020            */
1021            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1022                    java.lang.String structureId, int start, int end,
1023                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1024                    return getPersistence()
1025                                       .findByStructureId(structureId, start, end, orderByComparator);
1026            }
1027    
1028            /**
1029            * Returns the first journal article in the ordered set where structureId = &#63;.
1030            *
1031            * @param structureId the structure ID
1032            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1033            * @return the first matching journal article
1034            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1035            */
1036            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
1037                    java.lang.String structureId,
1038                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1039                    throws com.liferay.portlet.journal.NoSuchArticleException {
1040                    return getPersistence()
1041                                       .findByStructureId_First(structureId, orderByComparator);
1042            }
1043    
1044            /**
1045            * Returns the first journal article in the ordered set where structureId = &#63;.
1046            *
1047            * @param structureId the structure ID
1048            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1049            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1050            */
1051            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First(
1052                    java.lang.String structureId,
1053                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1054                    return getPersistence()
1055                                       .fetchByStructureId_First(structureId, orderByComparator);
1056            }
1057    
1058            /**
1059            * Returns the last journal article in the ordered set where structureId = &#63;.
1060            *
1061            * @param structureId the structure ID
1062            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1063            * @return the last matching journal article
1064            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1065            */
1066            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
1067                    java.lang.String structureId,
1068                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1069                    throws com.liferay.portlet.journal.NoSuchArticleException {
1070                    return getPersistence()
1071                                       .findByStructureId_Last(structureId, orderByComparator);
1072            }
1073    
1074            /**
1075            * Returns the last journal article in the ordered set where structureId = &#63;.
1076            *
1077            * @param structureId the structure ID
1078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1079            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1080            */
1081            public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last(
1082                    java.lang.String structureId,
1083                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1084                    return getPersistence()
1085                                       .fetchByStructureId_Last(structureId, orderByComparator);
1086            }
1087    
1088            /**
1089            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
1090            *
1091            * @param id the primary key of the current journal article
1092            * @param structureId the structure ID
1093            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1094            * @return the previous, current, and next journal article
1095            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1096            */
1097            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
1098                    long id, java.lang.String structureId,
1099                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1100                    throws com.liferay.portlet.journal.NoSuchArticleException {
1101                    return getPersistence()
1102                                       .findByStructureId_PrevAndNext(id, structureId,
1103                            orderByComparator);
1104            }
1105    
1106            /**
1107            * Returns all the journal articles where structureId = any &#63;.
1108            *
1109            * <p>
1110            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1111            * </p>
1112            *
1113            * @param structureIds the structure IDs
1114            * @return the matching journal articles
1115            */
1116            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1117                    java.lang.String[] structureIds) {
1118                    return getPersistence().findByStructureId(structureIds);
1119            }
1120    
1121            /**
1122            * Returns a range of all the journal articles where structureId = any &#63;.
1123            *
1124            * <p>
1125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1126            * </p>
1127            *
1128            * @param structureIds the structure IDs
1129            * @param start the lower bound of the range of journal articles
1130            * @param end the upper bound of the range of journal articles (not inclusive)
1131            * @return the range of matching journal articles
1132            */
1133            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1134                    java.lang.String[] structureIds, int start, int end) {
1135                    return getPersistence().findByStructureId(structureIds, start, end);
1136            }
1137    
1138            /**
1139            * Returns an ordered range of all the journal articles where structureId = any &#63;.
1140            *
1141            * <p>
1142            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1143            * </p>
1144            *
1145            * @param structureIds the structure IDs
1146            * @param start the lower bound of the range of journal articles
1147            * @param end the upper bound of the range of journal articles (not inclusive)
1148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1149            * @return the ordered range of matching journal articles
1150            */
1151            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId(
1152                    java.lang.String[] structureIds, int start, int end,
1153                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1154                    return getPersistence()
1155                                       .findByStructureId(structureIds, start, end,
1156                            orderByComparator);
1157            }
1158    
1159            /**
1160            * Removes all the journal articles where structureId = &#63; from the database.
1161            *
1162            * @param structureId the structure ID
1163            */
1164            public static void removeByStructureId(java.lang.String structureId) {
1165                    getPersistence().removeByStructureId(structureId);
1166            }
1167    
1168            /**
1169            * Returns the number of journal articles where structureId = &#63;.
1170            *
1171            * @param structureId the structure ID
1172            * @return the number of matching journal articles
1173            */
1174            public static int countByStructureId(java.lang.String structureId) {
1175                    return getPersistence().countByStructureId(structureId);
1176            }
1177    
1178            /**
1179            * Returns the number of journal articles where structureId = any &#63;.
1180            *
1181            * @param structureIds the structure IDs
1182            * @return the number of matching journal articles
1183            */
1184            public static int countByStructureId(java.lang.String[] structureIds) {
1185                    return getPersistence().countByStructureId(structureIds);
1186            }
1187    
1188            /**
1189            * Returns all the journal articles where templateId = &#63;.
1190            *
1191            * @param templateId the template ID
1192            * @return the matching journal articles
1193            */
1194            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1195                    java.lang.String templateId) {
1196                    return getPersistence().findByTemplateId(templateId);
1197            }
1198    
1199            /**
1200            * Returns a range of all the journal articles where templateId = &#63;.
1201            *
1202            * <p>
1203            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1204            * </p>
1205            *
1206            * @param templateId the template ID
1207            * @param start the lower bound of the range of journal articles
1208            * @param end the upper bound of the range of journal articles (not inclusive)
1209            * @return the range of matching journal articles
1210            */
1211            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1212                    java.lang.String templateId, int start, int end) {
1213                    return getPersistence().findByTemplateId(templateId, start, end);
1214            }
1215    
1216            /**
1217            * Returns an ordered range of all the journal articles where templateId = &#63;.
1218            *
1219            * <p>
1220            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1221            * </p>
1222            *
1223            * @param templateId the template ID
1224            * @param start the lower bound of the range of journal articles
1225            * @param end the upper bound of the range of journal articles (not inclusive)
1226            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1227            * @return the ordered range of matching journal articles
1228            */
1229            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
1230                    java.lang.String templateId, int start, int end,
1231                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1232                    return getPersistence()
1233                                       .findByTemplateId(templateId, start, end, orderByComparator);
1234            }
1235    
1236            /**
1237            * Returns the first journal article in the ordered set where templateId = &#63;.
1238            *
1239            * @param templateId the template ID
1240            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1241            * @return the first matching journal article
1242            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1243            */
1244            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
1245                    java.lang.String templateId,
1246                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1247                    throws com.liferay.portlet.journal.NoSuchArticleException {
1248                    return getPersistence()
1249                                       .findByTemplateId_First(templateId, orderByComparator);
1250            }
1251    
1252            /**
1253            * Returns the first journal article in the ordered set where templateId = &#63;.
1254            *
1255            * @param templateId the template ID
1256            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1257            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1258            */
1259            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First(
1260                    java.lang.String templateId,
1261                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1262                    return getPersistence()
1263                                       .fetchByTemplateId_First(templateId, orderByComparator);
1264            }
1265    
1266            /**
1267            * Returns the last journal article in the ordered set where templateId = &#63;.
1268            *
1269            * @param templateId the template ID
1270            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1271            * @return the last matching journal article
1272            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1273            */
1274            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1275                    java.lang.String templateId,
1276                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1277                    throws com.liferay.portlet.journal.NoSuchArticleException {
1278                    return getPersistence()
1279                                       .findByTemplateId_Last(templateId, orderByComparator);
1280            }
1281    
1282            /**
1283            * Returns the last journal article in the ordered set where templateId = &#63;.
1284            *
1285            * @param templateId the template ID
1286            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1287            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1288            */
1289            public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last(
1290                    java.lang.String templateId,
1291                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1292                    return getPersistence()
1293                                       .fetchByTemplateId_Last(templateId, orderByComparator);
1294            }
1295    
1296            /**
1297            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1298            *
1299            * @param id the primary key of the current journal article
1300            * @param templateId the template ID
1301            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1302            * @return the previous, current, and next journal article
1303            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1304            */
1305            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1306                    long id, java.lang.String templateId,
1307                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1308                    throws com.liferay.portlet.journal.NoSuchArticleException {
1309                    return getPersistence()
1310                                       .findByTemplateId_PrevAndNext(id, templateId,
1311                            orderByComparator);
1312            }
1313    
1314            /**
1315            * Removes all the journal articles where templateId = &#63; from the database.
1316            *
1317            * @param templateId the template ID
1318            */
1319            public static void removeByTemplateId(java.lang.String templateId) {
1320                    getPersistence().removeByTemplateId(templateId);
1321            }
1322    
1323            /**
1324            * Returns the number of journal articles where templateId = &#63;.
1325            *
1326            * @param templateId the template ID
1327            * @return the number of matching journal articles
1328            */
1329            public static int countByTemplateId(java.lang.String templateId) {
1330                    return getPersistence().countByTemplateId(templateId);
1331            }
1332    
1333            /**
1334            * Returns all the journal articles where layoutUuid = &#63;.
1335            *
1336            * @param layoutUuid the layout uuid
1337            * @return the matching journal articles
1338            */
1339            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1340                    java.lang.String layoutUuid) {
1341                    return getPersistence().findByLayoutUuid(layoutUuid);
1342            }
1343    
1344            /**
1345            * Returns a range of all the journal articles where layoutUuid = &#63;.
1346            *
1347            * <p>
1348            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1349            * </p>
1350            *
1351            * @param layoutUuid the layout uuid
1352            * @param start the lower bound of the range of journal articles
1353            * @param end the upper bound of the range of journal articles (not inclusive)
1354            * @return the range of matching journal articles
1355            */
1356            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1357                    java.lang.String layoutUuid, int start, int end) {
1358                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1359            }
1360    
1361            /**
1362            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1363            *
1364            * <p>
1365            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1366            * </p>
1367            *
1368            * @param layoutUuid the layout uuid
1369            * @param start the lower bound of the range of journal articles
1370            * @param end the upper bound of the range of journal articles (not inclusive)
1371            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1372            * @return the ordered range of matching journal articles
1373            */
1374            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid(
1375                    java.lang.String layoutUuid, int start, int end,
1376                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1377                    return getPersistence()
1378                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1379            }
1380    
1381            /**
1382            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1383            *
1384            * @param layoutUuid the layout uuid
1385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1386            * @return the first matching journal article
1387            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1388            */
1389            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First(
1390                    java.lang.String layoutUuid,
1391                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1392                    throws com.liferay.portlet.journal.NoSuchArticleException {
1393                    return getPersistence()
1394                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1395            }
1396    
1397            /**
1398            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1399            *
1400            * @param layoutUuid the layout uuid
1401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1402            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1403            */
1404            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First(
1405                    java.lang.String layoutUuid,
1406                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1407                    return getPersistence()
1408                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1409            }
1410    
1411            /**
1412            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1413            *
1414            * @param layoutUuid the layout uuid
1415            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1416            * @return the last matching journal article
1417            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1418            */
1419            public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last(
1420                    java.lang.String layoutUuid,
1421                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1422                    throws com.liferay.portlet.journal.NoSuchArticleException {
1423                    return getPersistence()
1424                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1425            }
1426    
1427            /**
1428            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1429            *
1430            * @param layoutUuid the layout uuid
1431            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1432            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1433            */
1434            public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last(
1435                    java.lang.String layoutUuid,
1436                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1437                    return getPersistence()
1438                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1439            }
1440    
1441            /**
1442            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1443            *
1444            * @param id the primary key of the current journal article
1445            * @param layoutUuid the layout uuid
1446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1447            * @return the previous, current, and next journal article
1448            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1449            */
1450            public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext(
1451                    long id, java.lang.String layoutUuid,
1452                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1453                    throws com.liferay.portlet.journal.NoSuchArticleException {
1454                    return getPersistence()
1455                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1456                            orderByComparator);
1457            }
1458    
1459            /**
1460            * Removes all the journal articles where layoutUuid = &#63; from the database.
1461            *
1462            * @param layoutUuid the layout uuid
1463            */
1464            public static void removeByLayoutUuid(java.lang.String layoutUuid) {
1465                    getPersistence().removeByLayoutUuid(layoutUuid);
1466            }
1467    
1468            /**
1469            * Returns the number of journal articles where layoutUuid = &#63;.
1470            *
1471            * @param layoutUuid the layout uuid
1472            * @return the number of matching journal articles
1473            */
1474            public static int countByLayoutUuid(java.lang.String layoutUuid) {
1475                    return getPersistence().countByLayoutUuid(layoutUuid);
1476            }
1477    
1478            /**
1479            * Returns all the journal articles where smallImageId = &#63;.
1480            *
1481            * @param smallImageId the small image ID
1482            * @return the matching journal articles
1483            */
1484            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1485                    long smallImageId) {
1486                    return getPersistence().findBySmallImageId(smallImageId);
1487            }
1488    
1489            /**
1490            * Returns a range of all the journal articles where smallImageId = &#63;.
1491            *
1492            * <p>
1493            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1494            * </p>
1495            *
1496            * @param smallImageId the small image ID
1497            * @param start the lower bound of the range of journal articles
1498            * @param end the upper bound of the range of journal articles (not inclusive)
1499            * @return the range of matching journal articles
1500            */
1501            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1502                    long smallImageId, int start, int end) {
1503                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1504            }
1505    
1506            /**
1507            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1508            *
1509            * <p>
1510            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1511            * </p>
1512            *
1513            * @param smallImageId the small image ID
1514            * @param start the lower bound of the range of journal articles
1515            * @param end the upper bound of the range of journal articles (not inclusive)
1516            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1517            * @return the ordered range of matching journal articles
1518            */
1519            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1520                    long smallImageId, int start, int end,
1521                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1522                    return getPersistence()
1523                                       .findBySmallImageId(smallImageId, start, end,
1524                            orderByComparator);
1525            }
1526    
1527            /**
1528            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1529            *
1530            * @param smallImageId the small image ID
1531            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1532            * @return the first matching journal article
1533            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1534            */
1535            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1536                    long smallImageId,
1537                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1538                    throws com.liferay.portlet.journal.NoSuchArticleException {
1539                    return getPersistence()
1540                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1541            }
1542    
1543            /**
1544            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1545            *
1546            * @param smallImageId the small image ID
1547            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1548            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1549            */
1550            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First(
1551                    long smallImageId,
1552                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1553                    return getPersistence()
1554                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1555            }
1556    
1557            /**
1558            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1559            *
1560            * @param smallImageId the small image ID
1561            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1562            * @return the last matching journal article
1563            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1564            */
1565            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1566                    long smallImageId,
1567                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1568                    throws com.liferay.portlet.journal.NoSuchArticleException {
1569                    return getPersistence()
1570                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1571            }
1572    
1573            /**
1574            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1575            *
1576            * @param smallImageId the small image ID
1577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1578            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1579            */
1580            public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last(
1581                    long smallImageId,
1582                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1583                    return getPersistence()
1584                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1585            }
1586    
1587            /**
1588            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1589            *
1590            * @param id the primary key of the current journal article
1591            * @param smallImageId the small image ID
1592            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1593            * @return the previous, current, and next journal article
1594            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1595            */
1596            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1597                    long id, long smallImageId,
1598                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1599                    throws com.liferay.portlet.journal.NoSuchArticleException {
1600                    return getPersistence()
1601                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1602                            orderByComparator);
1603            }
1604    
1605            /**
1606            * Removes all the journal articles where smallImageId = &#63; from the database.
1607            *
1608            * @param smallImageId the small image ID
1609            */
1610            public static void removeBySmallImageId(long smallImageId) {
1611                    getPersistence().removeBySmallImageId(smallImageId);
1612            }
1613    
1614            /**
1615            * Returns the number of journal articles where smallImageId = &#63;.
1616            *
1617            * @param smallImageId the small image ID
1618            * @return the number of matching journal articles
1619            */
1620            public static int countBySmallImageId(long smallImageId) {
1621                    return getPersistence().countBySmallImageId(smallImageId);
1622            }
1623    
1624            /**
1625            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1626            *
1627            * @param resourcePrimKey the resource prim key
1628            * @param indexable the indexable
1629            * @return the matching journal articles
1630            */
1631            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1632                    long resourcePrimKey, boolean indexable) {
1633                    return getPersistence().findByR_I(resourcePrimKey, indexable);
1634            }
1635    
1636            /**
1637            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1638            *
1639            * <p>
1640            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1641            * </p>
1642            *
1643            * @param resourcePrimKey the resource prim key
1644            * @param indexable the indexable
1645            * @param start the lower bound of the range of journal articles
1646            * @param end the upper bound of the range of journal articles (not inclusive)
1647            * @return the range of matching journal articles
1648            */
1649            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1650                    long resourcePrimKey, boolean indexable, int start, int end) {
1651                    return getPersistence().findByR_I(resourcePrimKey, indexable, start, end);
1652            }
1653    
1654            /**
1655            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1656            *
1657            * <p>
1658            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1659            * </p>
1660            *
1661            * @param resourcePrimKey the resource prim key
1662            * @param indexable the indexable
1663            * @param start the lower bound of the range of journal articles
1664            * @param end the upper bound of the range of journal articles (not inclusive)
1665            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1666            * @return the ordered range of matching journal articles
1667            */
1668            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I(
1669                    long resourcePrimKey, boolean indexable, int start, int end,
1670                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1671                    return getPersistence()
1672                                       .findByR_I(resourcePrimKey, indexable, start, end,
1673                            orderByComparator);
1674            }
1675    
1676            /**
1677            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1678            *
1679            * @param resourcePrimKey the resource prim key
1680            * @param indexable the indexable
1681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1682            * @return the first matching journal article
1683            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1684            */
1685            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_First(
1686                    long resourcePrimKey, boolean indexable,
1687                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1688                    throws com.liferay.portlet.journal.NoSuchArticleException {
1689                    return getPersistence()
1690                                       .findByR_I_First(resourcePrimKey, indexable,
1691                            orderByComparator);
1692            }
1693    
1694            /**
1695            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1696            *
1697            * @param resourcePrimKey the resource prim key
1698            * @param indexable the indexable
1699            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1700            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1701            */
1702            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_First(
1703                    long resourcePrimKey, boolean indexable,
1704                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1705                    return getPersistence()
1706                                       .fetchByR_I_First(resourcePrimKey, indexable,
1707                            orderByComparator);
1708            }
1709    
1710            /**
1711            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1712            *
1713            * @param resourcePrimKey the resource prim key
1714            * @param indexable the indexable
1715            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1716            * @return the last matching journal article
1717            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1718            */
1719            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_Last(
1720                    long resourcePrimKey, boolean indexable,
1721                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1722                    throws com.liferay.portlet.journal.NoSuchArticleException {
1723                    return getPersistence()
1724                                       .findByR_I_Last(resourcePrimKey, indexable, orderByComparator);
1725            }
1726    
1727            /**
1728            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1729            *
1730            * @param resourcePrimKey the resource prim key
1731            * @param indexable the indexable
1732            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1733            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1734            */
1735            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_Last(
1736                    long resourcePrimKey, boolean indexable,
1737                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1738                    return getPersistence()
1739                                       .fetchByR_I_Last(resourcePrimKey, indexable,
1740                            orderByComparator);
1741            }
1742    
1743            /**
1744            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1745            *
1746            * @param id the primary key of the current journal article
1747            * @param resourcePrimKey the resource prim key
1748            * @param indexable the indexable
1749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1750            * @return the previous, current, and next journal article
1751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1752            */
1753            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_PrevAndNext(
1754                    long id, long resourcePrimKey, boolean indexable,
1755                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1756                    throws com.liferay.portlet.journal.NoSuchArticleException {
1757                    return getPersistence()
1758                                       .findByR_I_PrevAndNext(id, resourcePrimKey, indexable,
1759                            orderByComparator);
1760            }
1761    
1762            /**
1763            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; from the database.
1764            *
1765            * @param resourcePrimKey the resource prim key
1766            * @param indexable the indexable
1767            */
1768            public static void removeByR_I(long resourcePrimKey, boolean indexable) {
1769                    getPersistence().removeByR_I(resourcePrimKey, indexable);
1770            }
1771    
1772            /**
1773            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1774            *
1775            * @param resourcePrimKey the resource prim key
1776            * @param indexable the indexable
1777            * @return the number of matching journal articles
1778            */
1779            public static int countByR_I(long resourcePrimKey, boolean indexable) {
1780                    return getPersistence().countByR_I(resourcePrimKey, indexable);
1781            }
1782    
1783            /**
1784            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1785            *
1786            * @param resourcePrimKey the resource prim key
1787            * @param status the status
1788            * @return the matching journal articles
1789            */
1790            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1791                    long resourcePrimKey, int status) {
1792                    return getPersistence().findByR_ST(resourcePrimKey, status);
1793            }
1794    
1795            /**
1796            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1797            *
1798            * <p>
1799            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1800            * </p>
1801            *
1802            * @param resourcePrimKey the resource prim key
1803            * @param status the status
1804            * @param start the lower bound of the range of journal articles
1805            * @param end the upper bound of the range of journal articles (not inclusive)
1806            * @return the range of matching journal articles
1807            */
1808            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1809                    long resourcePrimKey, int status, int start, int end) {
1810                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1811            }
1812    
1813            /**
1814            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1815            *
1816            * <p>
1817            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1818            * </p>
1819            *
1820            * @param resourcePrimKey the resource prim key
1821            * @param status the status
1822            * @param start the lower bound of the range of journal articles
1823            * @param end the upper bound of the range of journal articles (not inclusive)
1824            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1825            * @return the ordered range of matching journal articles
1826            */
1827            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1828                    long resourcePrimKey, int status, int start, int end,
1829                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1830                    return getPersistence()
1831                                       .findByR_ST(resourcePrimKey, status, start, end,
1832                            orderByComparator);
1833            }
1834    
1835            /**
1836            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1837            *
1838            * @param resourcePrimKey the resource prim key
1839            * @param status the status
1840            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1841            * @return the first matching journal article
1842            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1843            */
1844            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1845                    long resourcePrimKey, int status,
1846                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1847                    throws com.liferay.portlet.journal.NoSuchArticleException {
1848                    return getPersistence()
1849                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1850            }
1851    
1852            /**
1853            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1854            *
1855            * @param resourcePrimKey the resource prim key
1856            * @param status the status
1857            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1858            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1859            */
1860            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First(
1861                    long resourcePrimKey, int status,
1862                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1863                    return getPersistence()
1864                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
1865            }
1866    
1867            /**
1868            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1869            *
1870            * @param resourcePrimKey the resource prim key
1871            * @param status the status
1872            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1873            * @return the last matching journal article
1874            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1875            */
1876            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1877                    long resourcePrimKey, int status,
1878                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1879                    throws com.liferay.portlet.journal.NoSuchArticleException {
1880                    return getPersistence()
1881                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1882            }
1883    
1884            /**
1885            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1886            *
1887            * @param resourcePrimKey the resource prim key
1888            * @param status the status
1889            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1890            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1891            */
1892            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last(
1893                    long resourcePrimKey, int status,
1894                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1895                    return getPersistence()
1896                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
1897            }
1898    
1899            /**
1900            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1901            *
1902            * @param id the primary key of the current journal article
1903            * @param resourcePrimKey the resource prim key
1904            * @param status the status
1905            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1906            * @return the previous, current, and next journal article
1907            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1908            */
1909            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1910                    long id, long resourcePrimKey, int status,
1911                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
1912                    throws com.liferay.portlet.journal.NoSuchArticleException {
1913                    return getPersistence()
1914                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1915                            orderByComparator);
1916            }
1917    
1918            /**
1919            * Returns all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1920            *
1921            * <p>
1922            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1923            * </p>
1924            *
1925            * @param resourcePrimKey the resource prim key
1926            * @param statuses the statuses
1927            * @return the matching journal articles
1928            */
1929            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1930                    long resourcePrimKey, int[] statuses) {
1931                    return getPersistence().findByR_ST(resourcePrimKey, statuses);
1932            }
1933    
1934            /**
1935            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1936            *
1937            * <p>
1938            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1939            * </p>
1940            *
1941            * @param resourcePrimKey the resource prim key
1942            * @param statuses the statuses
1943            * @param start the lower bound of the range of journal articles
1944            * @param end the upper bound of the range of journal articles (not inclusive)
1945            * @return the range of matching journal articles
1946            */
1947            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1948                    long resourcePrimKey, int[] statuses, int start, int end) {
1949                    return getPersistence().findByR_ST(resourcePrimKey, statuses, start, end);
1950            }
1951    
1952            /**
1953            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1954            *
1955            * <p>
1956            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
1957            * </p>
1958            *
1959            * @param resourcePrimKey the resource prim key
1960            * @param statuses the statuses
1961            * @param start the lower bound of the range of journal articles
1962            * @param end the upper bound of the range of journal articles (not inclusive)
1963            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1964            * @return the ordered range of matching journal articles
1965            */
1966            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1967                    long resourcePrimKey, int[] statuses, int start, int end,
1968                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
1969                    return getPersistence()
1970                                       .findByR_ST(resourcePrimKey, statuses, start, end,
1971                            orderByComparator);
1972            }
1973    
1974            /**
1975            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
1976            *
1977            * @param resourcePrimKey the resource prim key
1978            * @param status the status
1979            */
1980            public static void removeByR_ST(long resourcePrimKey, int status) {
1981                    getPersistence().removeByR_ST(resourcePrimKey, status);
1982            }
1983    
1984            /**
1985            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
1986            *
1987            * @param resourcePrimKey the resource prim key
1988            * @param status the status
1989            * @return the number of matching journal articles
1990            */
1991            public static int countByR_ST(long resourcePrimKey, int status) {
1992                    return getPersistence().countByR_ST(resourcePrimKey, status);
1993            }
1994    
1995            /**
1996            * Returns the number of journal articles where resourcePrimKey = &#63; and status = any &#63;.
1997            *
1998            * @param resourcePrimKey the resource prim key
1999            * @param statuses the statuses
2000            * @return the number of matching journal articles
2001            */
2002            public static int countByR_ST(long resourcePrimKey, int[] statuses) {
2003                    return getPersistence().countByR_ST(resourcePrimKey, statuses);
2004            }
2005    
2006            /**
2007            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
2008            *
2009            * @param groupId the group ID
2010            * @param userId the user ID
2011            * @return the matching journal articles
2012            */
2013            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2014                    long groupId, long userId) {
2015                    return getPersistence().findByG_U(groupId, userId);
2016            }
2017    
2018            /**
2019            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
2020            *
2021            * <p>
2022            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2023            * </p>
2024            *
2025            * @param groupId the group ID
2026            * @param userId the user ID
2027            * @param start the lower bound of the range of journal articles
2028            * @param end the upper bound of the range of journal articles (not inclusive)
2029            * @return the range of matching journal articles
2030            */
2031            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2032                    long groupId, long userId, int start, int end) {
2033                    return getPersistence().findByG_U(groupId, userId, start, end);
2034            }
2035    
2036            /**
2037            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
2038            *
2039            * <p>
2040            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2041            * </p>
2042            *
2043            * @param groupId the group ID
2044            * @param userId the user ID
2045            * @param start the lower bound of the range of journal articles
2046            * @param end the upper bound of the range of journal articles (not inclusive)
2047            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2048            * @return the ordered range of matching journal articles
2049            */
2050            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U(
2051                    long groupId, long userId, int start, int end,
2052                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2053                    return getPersistence()
2054                                       .findByG_U(groupId, userId, start, end, orderByComparator);
2055            }
2056    
2057            /**
2058            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2059            *
2060            * @param groupId the group ID
2061            * @param userId the user ID
2062            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2063            * @return the first matching journal article
2064            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2065            */
2066            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First(
2067                    long groupId, long userId,
2068                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2069                    throws com.liferay.portlet.journal.NoSuchArticleException {
2070                    return getPersistence()
2071                                       .findByG_U_First(groupId, userId, orderByComparator);
2072            }
2073    
2074            /**
2075            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2076            *
2077            * @param groupId the group ID
2078            * @param userId the user ID
2079            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2080            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2081            */
2082            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First(
2083                    long groupId, long userId,
2084                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2085                    return getPersistence()
2086                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2087            }
2088    
2089            /**
2090            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2091            *
2092            * @param groupId the group ID
2093            * @param userId the user ID
2094            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2095            * @return the last matching journal article
2096            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2097            */
2098            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last(
2099                    long groupId, long userId,
2100                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2101                    throws com.liferay.portlet.journal.NoSuchArticleException {
2102                    return getPersistence()
2103                                       .findByG_U_Last(groupId, userId, orderByComparator);
2104            }
2105    
2106            /**
2107            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2108            *
2109            * @param groupId the group ID
2110            * @param userId the user ID
2111            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2112            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2113            */
2114            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last(
2115                    long groupId, long userId,
2116                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2117                    return getPersistence()
2118                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2119            }
2120    
2121            /**
2122            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2123            *
2124            * @param id the primary key of the current journal article
2125            * @param groupId the group ID
2126            * @param userId the user ID
2127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2128            * @return the previous, current, and next journal article
2129            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2130            */
2131            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext(
2132                    long id, long groupId, long userId,
2133                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2134                    throws com.liferay.portlet.journal.NoSuchArticleException {
2135                    return getPersistence()
2136                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2137            }
2138    
2139            /**
2140            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2141            *
2142            * @param groupId the group ID
2143            * @param userId the user ID
2144            * @return the matching journal articles that the user has permission to view
2145            */
2146            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2147                    long groupId, long userId) {
2148                    return getPersistence().filterFindByG_U(groupId, userId);
2149            }
2150    
2151            /**
2152            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2153            *
2154            * <p>
2155            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2156            * </p>
2157            *
2158            * @param groupId the group ID
2159            * @param userId the user ID
2160            * @param start the lower bound of the range of journal articles
2161            * @param end the upper bound of the range of journal articles (not inclusive)
2162            * @return the range of matching journal articles that the user has permission to view
2163            */
2164            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2165                    long groupId, long userId, int start, int end) {
2166                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2167            }
2168    
2169            /**
2170            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2171            *
2172            * <p>
2173            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2174            * </p>
2175            *
2176            * @param groupId the group ID
2177            * @param userId the user ID
2178            * @param start the lower bound of the range of journal articles
2179            * @param end the upper bound of the range of journal articles (not inclusive)
2180            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2181            * @return the ordered range of matching journal articles that the user has permission to view
2182            */
2183            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U(
2184                    long groupId, long userId, int start, int end,
2185                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2186                    return getPersistence()
2187                                       .filterFindByG_U(groupId, userId, start, end,
2188                            orderByComparator);
2189            }
2190    
2191            /**
2192            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2193            *
2194            * @param id the primary key of the current journal article
2195            * @param groupId the group ID
2196            * @param userId the user ID
2197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2198            * @return the previous, current, and next journal article
2199            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2200            */
2201            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext(
2202                    long id, long groupId, long userId,
2203                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2204                    throws com.liferay.portlet.journal.NoSuchArticleException {
2205                    return getPersistence()
2206                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2207                            orderByComparator);
2208            }
2209    
2210            /**
2211            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2212            *
2213            * @param groupId the group ID
2214            * @param userId the user ID
2215            */
2216            public static void removeByG_U(long groupId, long userId) {
2217                    getPersistence().removeByG_U(groupId, userId);
2218            }
2219    
2220            /**
2221            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2222            *
2223            * @param groupId the group ID
2224            * @param userId the user ID
2225            * @return the number of matching journal articles
2226            */
2227            public static int countByG_U(long groupId, long userId) {
2228                    return getPersistence().countByG_U(groupId, userId);
2229            }
2230    
2231            /**
2232            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2233            *
2234            * @param groupId the group ID
2235            * @param userId the user ID
2236            * @return the number of matching journal articles that the user has permission to view
2237            */
2238            public static int filterCountByG_U(long groupId, long userId) {
2239                    return getPersistence().filterCountByG_U(groupId, userId);
2240            }
2241    
2242            /**
2243            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2244            *
2245            * @param groupId the group ID
2246            * @param folderId the folder ID
2247            * @return the matching journal articles
2248            */
2249            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2250                    long groupId, long folderId) {
2251                    return getPersistence().findByG_F(groupId, folderId);
2252            }
2253    
2254            /**
2255            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2256            *
2257            * <p>
2258            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2259            * </p>
2260            *
2261            * @param groupId the group ID
2262            * @param folderId the folder ID
2263            * @param start the lower bound of the range of journal articles
2264            * @param end the upper bound of the range of journal articles (not inclusive)
2265            * @return the range of matching journal articles
2266            */
2267            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2268                    long groupId, long folderId, int start, int end) {
2269                    return getPersistence().findByG_F(groupId, folderId, start, end);
2270            }
2271    
2272            /**
2273            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2274            *
2275            * <p>
2276            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2277            * </p>
2278            *
2279            * @param groupId the group ID
2280            * @param folderId the folder ID
2281            * @param start the lower bound of the range of journal articles
2282            * @param end the upper bound of the range of journal articles (not inclusive)
2283            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2284            * @return the ordered range of matching journal articles
2285            */
2286            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2287                    long groupId, long folderId, int start, int end,
2288                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2289                    return getPersistence()
2290                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2291            }
2292    
2293            /**
2294            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2295            *
2296            * @param groupId the group ID
2297            * @param folderId the folder ID
2298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2299            * @return the first matching journal article
2300            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2301            */
2302            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First(
2303                    long groupId, long folderId,
2304                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2305                    throws com.liferay.portlet.journal.NoSuchArticleException {
2306                    return getPersistence()
2307                                       .findByG_F_First(groupId, folderId, orderByComparator);
2308            }
2309    
2310            /**
2311            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2312            *
2313            * @param groupId the group ID
2314            * @param folderId the folder ID
2315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2316            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2317            */
2318            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First(
2319                    long groupId, long folderId,
2320                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2321                    return getPersistence()
2322                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2323            }
2324    
2325            /**
2326            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2327            *
2328            * @param groupId the group ID
2329            * @param folderId the folder ID
2330            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2331            * @return the last matching journal article
2332            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2333            */
2334            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last(
2335                    long groupId, long folderId,
2336                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2337                    throws com.liferay.portlet.journal.NoSuchArticleException {
2338                    return getPersistence()
2339                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2340            }
2341    
2342            /**
2343            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2344            *
2345            * @param groupId the group ID
2346            * @param folderId the folder ID
2347            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2348            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2349            */
2350            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last(
2351                    long groupId, long folderId,
2352                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2353                    return getPersistence()
2354                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2355            }
2356    
2357            /**
2358            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2359            *
2360            * @param id the primary key of the current journal article
2361            * @param groupId the group ID
2362            * @param folderId the folder ID
2363            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2364            * @return the previous, current, and next journal article
2365            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2366            */
2367            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext(
2368                    long id, long groupId, long folderId,
2369                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2370                    throws com.liferay.portlet.journal.NoSuchArticleException {
2371                    return getPersistence()
2372                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2373                            orderByComparator);
2374            }
2375    
2376            /**
2377            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2378            *
2379            * @param groupId the group ID
2380            * @param folderId the folder ID
2381            * @return the matching journal articles that the user has permission to view
2382            */
2383            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2384                    long groupId, long folderId) {
2385                    return getPersistence().filterFindByG_F(groupId, folderId);
2386            }
2387    
2388            /**
2389            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2390            *
2391            * <p>
2392            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2393            * </p>
2394            *
2395            * @param groupId the group ID
2396            * @param folderId the folder ID
2397            * @param start the lower bound of the range of journal articles
2398            * @param end the upper bound of the range of journal articles (not inclusive)
2399            * @return the range of matching journal articles that the user has permission to view
2400            */
2401            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2402                    long groupId, long folderId, int start, int end) {
2403                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2404            }
2405    
2406            /**
2407            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2408            *
2409            * <p>
2410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2411            * </p>
2412            *
2413            * @param groupId the group ID
2414            * @param folderId the folder ID
2415            * @param start the lower bound of the range of journal articles
2416            * @param end the upper bound of the range of journal articles (not inclusive)
2417            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2418            * @return the ordered range of matching journal articles that the user has permission to view
2419            */
2420            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2421                    long groupId, long folderId, int start, int end,
2422                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2423                    return getPersistence()
2424                                       .filterFindByG_F(groupId, folderId, start, end,
2425                            orderByComparator);
2426            }
2427    
2428            /**
2429            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2430            *
2431            * @param id the primary key of the current journal article
2432            * @param groupId the group ID
2433            * @param folderId the folder ID
2434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2435            * @return the previous, current, and next journal article
2436            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2437            */
2438            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext(
2439                    long id, long groupId, long folderId,
2440                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2441                    throws com.liferay.portlet.journal.NoSuchArticleException {
2442                    return getPersistence()
2443                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2444                            orderByComparator);
2445            }
2446    
2447            /**
2448            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2449            *
2450            * @param groupId the group ID
2451            * @param folderIds the folder IDs
2452            * @return the matching journal articles that the user has permission to view
2453            */
2454            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2455                    long groupId, long[] folderIds) {
2456                    return getPersistence().filterFindByG_F(groupId, folderIds);
2457            }
2458    
2459            /**
2460            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2461            *
2462            * <p>
2463            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2464            * </p>
2465            *
2466            * @param groupId the group ID
2467            * @param folderIds the folder IDs
2468            * @param start the lower bound of the range of journal articles
2469            * @param end the upper bound of the range of journal articles (not inclusive)
2470            * @return the range of matching journal articles that the user has permission to view
2471            */
2472            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2473                    long groupId, long[] folderIds, int start, int end) {
2474                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2475            }
2476    
2477            /**
2478            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2479            *
2480            * <p>
2481            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2482            * </p>
2483            *
2484            * @param groupId the group ID
2485            * @param folderIds the folder IDs
2486            * @param start the lower bound of the range of journal articles
2487            * @param end the upper bound of the range of journal articles (not inclusive)
2488            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2489            * @return the ordered range of matching journal articles that the user has permission to view
2490            */
2491            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F(
2492                    long groupId, long[] folderIds, int start, int end,
2493                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2494                    return getPersistence()
2495                                       .filterFindByG_F(groupId, folderIds, start, end,
2496                            orderByComparator);
2497            }
2498    
2499            /**
2500            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2501            *
2502            * <p>
2503            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2504            * </p>
2505            *
2506            * @param groupId the group ID
2507            * @param folderIds the folder IDs
2508            * @return the matching journal articles
2509            */
2510            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2511                    long groupId, long[] folderIds) {
2512                    return getPersistence().findByG_F(groupId, folderIds);
2513            }
2514    
2515            /**
2516            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2517            *
2518            * <p>
2519            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2520            * </p>
2521            *
2522            * @param groupId the group ID
2523            * @param folderIds the folder IDs
2524            * @param start the lower bound of the range of journal articles
2525            * @param end the upper bound of the range of journal articles (not inclusive)
2526            * @return the range of matching journal articles
2527            */
2528            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2529                    long groupId, long[] folderIds, int start, int end) {
2530                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2531            }
2532    
2533            /**
2534            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2535            *
2536            * <p>
2537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2538            * </p>
2539            *
2540            * @param groupId the group ID
2541            * @param folderIds the folder IDs
2542            * @param start the lower bound of the range of journal articles
2543            * @param end the upper bound of the range of journal articles (not inclusive)
2544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2545            * @return the ordered range of matching journal articles
2546            */
2547            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F(
2548                    long groupId, long[] folderIds, int start, int end,
2549                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2550                    return getPersistence()
2551                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2552            }
2553    
2554            /**
2555            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2556            *
2557            * @param groupId the group ID
2558            * @param folderId the folder ID
2559            */
2560            public static void removeByG_F(long groupId, long folderId) {
2561                    getPersistence().removeByG_F(groupId, folderId);
2562            }
2563    
2564            /**
2565            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2566            *
2567            * @param groupId the group ID
2568            * @param folderId the folder ID
2569            * @return the number of matching journal articles
2570            */
2571            public static int countByG_F(long groupId, long folderId) {
2572                    return getPersistence().countByG_F(groupId, folderId);
2573            }
2574    
2575            /**
2576            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2577            *
2578            * @param groupId the group ID
2579            * @param folderIds the folder IDs
2580            * @return the number of matching journal articles
2581            */
2582            public static int countByG_F(long groupId, long[] folderIds) {
2583                    return getPersistence().countByG_F(groupId, folderIds);
2584            }
2585    
2586            /**
2587            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2588            *
2589            * @param groupId the group ID
2590            * @param folderId the folder ID
2591            * @return the number of matching journal articles that the user has permission to view
2592            */
2593            public static int filterCountByG_F(long groupId, long folderId) {
2594                    return getPersistence().filterCountByG_F(groupId, folderId);
2595            }
2596    
2597            /**
2598            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2599            *
2600            * @param groupId the group ID
2601            * @param folderIds the folder IDs
2602            * @return the number of matching journal articles that the user has permission to view
2603            */
2604            public static int filterCountByG_F(long groupId, long[] folderIds) {
2605                    return getPersistence().filterCountByG_F(groupId, folderIds);
2606            }
2607    
2608            /**
2609            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2610            *
2611            * @param groupId the group ID
2612            * @param articleId the article ID
2613            * @return the matching journal articles
2614            */
2615            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2616                    long groupId, java.lang.String articleId) {
2617                    return getPersistence().findByG_A(groupId, articleId);
2618            }
2619    
2620            /**
2621            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2622            *
2623            * <p>
2624            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2625            * </p>
2626            *
2627            * @param groupId the group ID
2628            * @param articleId the article ID
2629            * @param start the lower bound of the range of journal articles
2630            * @param end the upper bound of the range of journal articles (not inclusive)
2631            * @return the range of matching journal articles
2632            */
2633            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2634                    long groupId, java.lang.String articleId, int start, int end) {
2635                    return getPersistence().findByG_A(groupId, articleId, start, end);
2636            }
2637    
2638            /**
2639            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2640            *
2641            * <p>
2642            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2643            * </p>
2644            *
2645            * @param groupId the group ID
2646            * @param articleId the article ID
2647            * @param start the lower bound of the range of journal articles
2648            * @param end the upper bound of the range of journal articles (not inclusive)
2649            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2650            * @return the ordered range of matching journal articles
2651            */
2652            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
2653                    long groupId, java.lang.String articleId, int start, int end,
2654                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2655                    return getPersistence()
2656                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2657            }
2658    
2659            /**
2660            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2661            *
2662            * @param groupId the group ID
2663            * @param articleId the article ID
2664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2665            * @return the first matching journal article
2666            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2667            */
2668            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
2669                    long groupId, java.lang.String articleId,
2670                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2671                    throws com.liferay.portlet.journal.NoSuchArticleException {
2672                    return getPersistence()
2673                                       .findByG_A_First(groupId, articleId, orderByComparator);
2674            }
2675    
2676            /**
2677            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2678            *
2679            * @param groupId the group ID
2680            * @param articleId the article ID
2681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2682            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2683            */
2684            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First(
2685                    long groupId, java.lang.String articleId,
2686                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2687                    return getPersistence()
2688                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
2689            }
2690    
2691            /**
2692            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2693            *
2694            * @param groupId the group ID
2695            * @param articleId the article ID
2696            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2697            * @return the last matching journal article
2698            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2699            */
2700            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
2701                    long groupId, java.lang.String articleId,
2702                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2703                    throws com.liferay.portlet.journal.NoSuchArticleException {
2704                    return getPersistence()
2705                                       .findByG_A_Last(groupId, articleId, orderByComparator);
2706            }
2707    
2708            /**
2709            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2710            *
2711            * @param groupId the group ID
2712            * @param articleId the article ID
2713            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2714            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2715            */
2716            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last(
2717                    long groupId, java.lang.String articleId,
2718                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2719                    return getPersistence()
2720                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
2721            }
2722    
2723            /**
2724            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2725            *
2726            * @param id the primary key of the current journal article
2727            * @param groupId the group ID
2728            * @param articleId the article ID
2729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2730            * @return the previous, current, and next journal article
2731            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2732            */
2733            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
2734                    long id, long groupId, java.lang.String articleId,
2735                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2736                    throws com.liferay.portlet.journal.NoSuchArticleException {
2737                    return getPersistence()
2738                                       .findByG_A_PrevAndNext(id, groupId, articleId,
2739                            orderByComparator);
2740            }
2741    
2742            /**
2743            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2744            *
2745            * @param groupId the group ID
2746            * @param articleId the article ID
2747            * @return the matching journal articles that the user has permission to view
2748            */
2749            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2750                    long groupId, java.lang.String articleId) {
2751                    return getPersistence().filterFindByG_A(groupId, articleId);
2752            }
2753    
2754            /**
2755            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2756            *
2757            * <p>
2758            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2759            * </p>
2760            *
2761            * @param groupId the group ID
2762            * @param articleId the article ID
2763            * @param start the lower bound of the range of journal articles
2764            * @param end the upper bound of the range of journal articles (not inclusive)
2765            * @return the range of matching journal articles that the user has permission to view
2766            */
2767            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2768                    long groupId, java.lang.String articleId, int start, int end) {
2769                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
2770            }
2771    
2772            /**
2773            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
2774            *
2775            * <p>
2776            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2777            * </p>
2778            *
2779            * @param groupId the group ID
2780            * @param articleId the article ID
2781            * @param start the lower bound of the range of journal articles
2782            * @param end the upper bound of the range of journal articles (not inclusive)
2783            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2784            * @return the ordered range of matching journal articles that the user has permission to view
2785            */
2786            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
2787                    long groupId, java.lang.String articleId, int start, int end,
2788                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2789                    return getPersistence()
2790                                       .filterFindByG_A(groupId, articleId, start, end,
2791                            orderByComparator);
2792            }
2793    
2794            /**
2795            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2796            *
2797            * @param id the primary key of the current journal article
2798            * @param groupId the group ID
2799            * @param articleId the article ID
2800            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2801            * @return the previous, current, and next journal article
2802            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2803            */
2804            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
2805                    long id, long groupId, java.lang.String articleId,
2806                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2807                    throws com.liferay.portlet.journal.NoSuchArticleException {
2808                    return getPersistence()
2809                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
2810                            orderByComparator);
2811            }
2812    
2813            /**
2814            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2815            *
2816            * @param groupId the group ID
2817            * @param articleId the article ID
2818            */
2819            public static void removeByG_A(long groupId, java.lang.String articleId) {
2820                    getPersistence().removeByG_A(groupId, articleId);
2821            }
2822    
2823            /**
2824            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
2825            *
2826            * @param groupId the group ID
2827            * @param articleId the article ID
2828            * @return the number of matching journal articles
2829            */
2830            public static int countByG_A(long groupId, java.lang.String articleId) {
2831                    return getPersistence().countByG_A(groupId, articleId);
2832            }
2833    
2834            /**
2835            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2836            *
2837            * @param groupId the group ID
2838            * @param articleId the article ID
2839            * @return the number of matching journal articles that the user has permission to view
2840            */
2841            public static int filterCountByG_A(long groupId, java.lang.String articleId) {
2842                    return getPersistence().filterCountByG_A(groupId, articleId);
2843            }
2844    
2845            /**
2846            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
2847            *
2848            * @param groupId the group ID
2849            * @param urlTitle the url title
2850            * @return the matching journal articles
2851            */
2852            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2853                    long groupId, java.lang.String urlTitle) {
2854                    return getPersistence().findByG_UT(groupId, urlTitle);
2855            }
2856    
2857            /**
2858            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2859            *
2860            * <p>
2861            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2862            * </p>
2863            *
2864            * @param groupId the group ID
2865            * @param urlTitle the url title
2866            * @param start the lower bound of the range of journal articles
2867            * @param end the upper bound of the range of journal articles (not inclusive)
2868            * @return the range of matching journal articles
2869            */
2870            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2871                    long groupId, java.lang.String urlTitle, int start, int end) {
2872                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
2873            }
2874    
2875            /**
2876            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2877            *
2878            * <p>
2879            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2880            * </p>
2881            *
2882            * @param groupId the group ID
2883            * @param urlTitle the url title
2884            * @param start the lower bound of the range of journal articles
2885            * @param end the upper bound of the range of journal articles (not inclusive)
2886            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2887            * @return the ordered range of matching journal articles
2888            */
2889            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
2890                    long groupId, java.lang.String urlTitle, int start, int end,
2891                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2892                    return getPersistence()
2893                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
2894            }
2895    
2896            /**
2897            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2898            *
2899            * @param groupId the group ID
2900            * @param urlTitle the url title
2901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2902            * @return the first matching journal article
2903            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2904            */
2905            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
2906                    long groupId, java.lang.String urlTitle,
2907                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2908                    throws com.liferay.portlet.journal.NoSuchArticleException {
2909                    return getPersistence()
2910                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
2911            }
2912    
2913            /**
2914            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2915            *
2916            * @param groupId the group ID
2917            * @param urlTitle the url title
2918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2919            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2920            */
2921            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First(
2922                    long groupId, java.lang.String urlTitle,
2923                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2924                    return getPersistence()
2925                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
2926            }
2927    
2928            /**
2929            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2930            *
2931            * @param groupId the group ID
2932            * @param urlTitle the url title
2933            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2934            * @return the last matching journal article
2935            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2936            */
2937            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
2938                    long groupId, java.lang.String urlTitle,
2939                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2940                    throws com.liferay.portlet.journal.NoSuchArticleException {
2941                    return getPersistence()
2942                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
2943            }
2944    
2945            /**
2946            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2947            *
2948            * @param groupId the group ID
2949            * @param urlTitle the url title
2950            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2951            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2952            */
2953            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last(
2954                    long groupId, java.lang.String urlTitle,
2955                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
2956                    return getPersistence()
2957                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
2958            }
2959    
2960            /**
2961            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2962            *
2963            * @param id the primary key of the current journal article
2964            * @param groupId the group ID
2965            * @param urlTitle the url title
2966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2967            * @return the previous, current, and next journal article
2968            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2969            */
2970            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
2971                    long id, long groupId, java.lang.String urlTitle,
2972                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
2973                    throws com.liferay.portlet.journal.NoSuchArticleException {
2974                    return getPersistence()
2975                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
2976                            orderByComparator);
2977            }
2978    
2979            /**
2980            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2981            *
2982            * @param groupId the group ID
2983            * @param urlTitle the url title
2984            * @return the matching journal articles that the user has permission to view
2985            */
2986            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
2987                    long groupId, java.lang.String urlTitle) {
2988                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
2989            }
2990    
2991            /**
2992            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2993            *
2994            * <p>
2995            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
2996            * </p>
2997            *
2998            * @param groupId the group ID
2999            * @param urlTitle the url title
3000            * @param start the lower bound of the range of journal articles
3001            * @param end the upper bound of the range of journal articles (not inclusive)
3002            * @return the range of matching journal articles that the user has permission to view
3003            */
3004            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3005                    long groupId, java.lang.String urlTitle, int start, int end) {
3006                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
3007            }
3008    
3009            /**
3010            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
3011            *
3012            * <p>
3013            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3014            * </p>
3015            *
3016            * @param groupId the group ID
3017            * @param urlTitle the url title
3018            * @param start the lower bound of the range of journal articles
3019            * @param end the upper bound of the range of journal articles (not inclusive)
3020            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3021            * @return the ordered range of matching journal articles that the user has permission to view
3022            */
3023            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
3024                    long groupId, java.lang.String urlTitle, int start, int end,
3025                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3026                    return getPersistence()
3027                                       .filterFindByG_UT(groupId, urlTitle, start, end,
3028                            orderByComparator);
3029            }
3030    
3031            /**
3032            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3033            *
3034            * @param id the primary key of the current journal article
3035            * @param groupId the group ID
3036            * @param urlTitle the url title
3037            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3038            * @return the previous, current, and next journal article
3039            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3040            */
3041            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
3042                    long id, long groupId, java.lang.String urlTitle,
3043                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3044                    throws com.liferay.portlet.journal.NoSuchArticleException {
3045                    return getPersistence()
3046                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
3047                            orderByComparator);
3048            }
3049    
3050            /**
3051            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3052            *
3053            * @param groupId the group ID
3054            * @param urlTitle the url title
3055            */
3056            public static void removeByG_UT(long groupId, java.lang.String urlTitle) {
3057                    getPersistence().removeByG_UT(groupId, urlTitle);
3058            }
3059    
3060            /**
3061            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3062            *
3063            * @param groupId the group ID
3064            * @param urlTitle the url title
3065            * @return the number of matching journal articles
3066            */
3067            public static int countByG_UT(long groupId, java.lang.String urlTitle) {
3068                    return getPersistence().countByG_UT(groupId, urlTitle);
3069            }
3070    
3071            /**
3072            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3073            *
3074            * @param groupId the group ID
3075            * @param urlTitle the url title
3076            * @return the number of matching journal articles that the user has permission to view
3077            */
3078            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) {
3079                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3080            }
3081    
3082            /**
3083            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
3084            *
3085            * @param groupId the group ID
3086            * @param structureId the structure ID
3087            * @return the matching journal articles
3088            */
3089            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3090                    long groupId, java.lang.String structureId) {
3091                    return getPersistence().findByG_S(groupId, structureId);
3092            }
3093    
3094            /**
3095            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
3096            *
3097            * <p>
3098            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3099            * </p>
3100            *
3101            * @param groupId the group ID
3102            * @param structureId the structure ID
3103            * @param start the lower bound of the range of journal articles
3104            * @param end the upper bound of the range of journal articles (not inclusive)
3105            * @return the range of matching journal articles
3106            */
3107            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3108                    long groupId, java.lang.String structureId, int start, int end) {
3109                    return getPersistence().findByG_S(groupId, structureId, start, end);
3110            }
3111    
3112            /**
3113            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
3114            *
3115            * <p>
3116            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3117            * </p>
3118            *
3119            * @param groupId the group ID
3120            * @param structureId the structure ID
3121            * @param start the lower bound of the range of journal articles
3122            * @param end the upper bound of the range of journal articles (not inclusive)
3123            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3124            * @return the ordered range of matching journal articles
3125            */
3126            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
3127                    long groupId, java.lang.String structureId, int start, int end,
3128                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3129                    return getPersistence()
3130                                       .findByG_S(groupId, structureId, start, end,
3131                            orderByComparator);
3132            }
3133    
3134            /**
3135            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3136            *
3137            * @param groupId the group ID
3138            * @param structureId the structure ID
3139            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3140            * @return the first matching journal article
3141            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3142            */
3143            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
3144                    long groupId, java.lang.String structureId,
3145                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3146                    throws com.liferay.portlet.journal.NoSuchArticleException {
3147                    return getPersistence()
3148                                       .findByG_S_First(groupId, structureId, orderByComparator);
3149            }
3150    
3151            /**
3152            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3153            *
3154            * @param groupId the group ID
3155            * @param structureId the structure ID
3156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3157            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3158            */
3159            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First(
3160                    long groupId, java.lang.String structureId,
3161                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3162                    return getPersistence()
3163                                       .fetchByG_S_First(groupId, structureId, orderByComparator);
3164            }
3165    
3166            /**
3167            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3168            *
3169            * @param groupId the group ID
3170            * @param structureId the structure ID
3171            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3172            * @return the last matching journal article
3173            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3174            */
3175            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
3176                    long groupId, java.lang.String structureId,
3177                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3178                    throws com.liferay.portlet.journal.NoSuchArticleException {
3179                    return getPersistence()
3180                                       .findByG_S_Last(groupId, structureId, orderByComparator);
3181            }
3182    
3183            /**
3184            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3185            *
3186            * @param groupId the group ID
3187            * @param structureId the structure ID
3188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3189            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3190            */
3191            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last(
3192                    long groupId, java.lang.String structureId,
3193                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3194                    return getPersistence()
3195                                       .fetchByG_S_Last(groupId, structureId, orderByComparator);
3196            }
3197    
3198            /**
3199            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
3200            *
3201            * @param id the primary key of the current journal article
3202            * @param groupId the group ID
3203            * @param structureId the structure ID
3204            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3205            * @return the previous, current, and next journal article
3206            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3207            */
3208            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
3209                    long id, long groupId, java.lang.String structureId,
3210                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3211                    throws com.liferay.portlet.journal.NoSuchArticleException {
3212                    return getPersistence()
3213                                       .findByG_S_PrevAndNext(id, groupId, structureId,
3214                            orderByComparator);
3215            }
3216    
3217            /**
3218            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3219            *
3220            * @param groupId the group ID
3221            * @param structureId the structure ID
3222            * @return the matching journal articles that the user has permission to view
3223            */
3224            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3225                    long groupId, java.lang.String structureId) {
3226                    return getPersistence().filterFindByG_S(groupId, structureId);
3227            }
3228    
3229            /**
3230            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3231            *
3232            * <p>
3233            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3234            * </p>
3235            *
3236            * @param groupId the group ID
3237            * @param structureId the structure ID
3238            * @param start the lower bound of the range of journal articles
3239            * @param end the upper bound of the range of journal articles (not inclusive)
3240            * @return the range of matching journal articles that the user has permission to view
3241            */
3242            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3243                    long groupId, java.lang.String structureId, int start, int end) {
3244                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
3245            }
3246    
3247            /**
3248            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
3249            *
3250            * <p>
3251            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3252            * </p>
3253            *
3254            * @param groupId the group ID
3255            * @param structureId the structure ID
3256            * @param start the lower bound of the range of journal articles
3257            * @param end the upper bound of the range of journal articles (not inclusive)
3258            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3259            * @return the ordered range of matching journal articles that the user has permission to view
3260            */
3261            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
3262                    long groupId, java.lang.String structureId, int start, int end,
3263                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3264                    return getPersistence()
3265                                       .filterFindByG_S(groupId, structureId, start, end,
3266                            orderByComparator);
3267            }
3268    
3269            /**
3270            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3271            *
3272            * @param id the primary key of the current journal article
3273            * @param groupId the group ID
3274            * @param structureId the structure ID
3275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3276            * @return the previous, current, and next journal article
3277            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3278            */
3279            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
3280                    long id, long groupId, java.lang.String structureId,
3281                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3282                    throws com.liferay.portlet.journal.NoSuchArticleException {
3283                    return getPersistence()
3284                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
3285                            orderByComparator);
3286            }
3287    
3288            /**
3289            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
3290            *
3291            * @param groupId the group ID
3292            * @param structureId the structure ID
3293            */
3294            public static void removeByG_S(long groupId, java.lang.String structureId) {
3295                    getPersistence().removeByG_S(groupId, structureId);
3296            }
3297    
3298            /**
3299            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
3300            *
3301            * @param groupId the group ID
3302            * @param structureId the structure ID
3303            * @return the number of matching journal articles
3304            */
3305            public static int countByG_S(long groupId, java.lang.String structureId) {
3306                    return getPersistence().countByG_S(groupId, structureId);
3307            }
3308    
3309            /**
3310            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
3311            *
3312            * @param groupId the group ID
3313            * @param structureId the structure ID
3314            * @return the number of matching journal articles that the user has permission to view
3315            */
3316            public static int filterCountByG_S(long groupId,
3317                    java.lang.String structureId) {
3318                    return getPersistence().filterCountByG_S(groupId, structureId);
3319            }
3320    
3321            /**
3322            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
3323            *
3324            * @param groupId the group ID
3325            * @param templateId the template ID
3326            * @return the matching journal articles
3327            */
3328            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3329                    long groupId, java.lang.String templateId) {
3330                    return getPersistence().findByG_T(groupId, templateId);
3331            }
3332    
3333            /**
3334            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
3335            *
3336            * <p>
3337            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3338            * </p>
3339            *
3340            * @param groupId the group ID
3341            * @param templateId the template ID
3342            * @param start the lower bound of the range of journal articles
3343            * @param end the upper bound of the range of journal articles (not inclusive)
3344            * @return the range of matching journal articles
3345            */
3346            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3347                    long groupId, java.lang.String templateId, int start, int end) {
3348                    return getPersistence().findByG_T(groupId, templateId, start, end);
3349            }
3350    
3351            /**
3352            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
3353            *
3354            * <p>
3355            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3356            * </p>
3357            *
3358            * @param groupId the group ID
3359            * @param templateId the template ID
3360            * @param start the lower bound of the range of journal articles
3361            * @param end the upper bound of the range of journal articles (not inclusive)
3362            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3363            * @return the ordered range of matching journal articles
3364            */
3365            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
3366                    long groupId, java.lang.String templateId, int start, int end,
3367                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3368                    return getPersistence()
3369                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
3370            }
3371    
3372            /**
3373            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3374            *
3375            * @param groupId the group ID
3376            * @param templateId the template ID
3377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3378            * @return the first matching journal article
3379            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3380            */
3381            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
3382                    long groupId, java.lang.String templateId,
3383                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3384                    throws com.liferay.portlet.journal.NoSuchArticleException {
3385                    return getPersistence()
3386                                       .findByG_T_First(groupId, templateId, orderByComparator);
3387            }
3388    
3389            /**
3390            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3391            *
3392            * @param groupId the group ID
3393            * @param templateId the template ID
3394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3395            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3396            */
3397            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First(
3398                    long groupId, java.lang.String templateId,
3399                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3400                    return getPersistence()
3401                                       .fetchByG_T_First(groupId, templateId, orderByComparator);
3402            }
3403    
3404            /**
3405            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3406            *
3407            * @param groupId the group ID
3408            * @param templateId the template ID
3409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3410            * @return the last matching journal article
3411            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3412            */
3413            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
3414                    long groupId, java.lang.String templateId,
3415                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3416                    throws com.liferay.portlet.journal.NoSuchArticleException {
3417                    return getPersistence()
3418                                       .findByG_T_Last(groupId, templateId, orderByComparator);
3419            }
3420    
3421            /**
3422            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3423            *
3424            * @param groupId the group ID
3425            * @param templateId the template ID
3426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3427            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3428            */
3429            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last(
3430                    long groupId, java.lang.String templateId,
3431                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3432                    return getPersistence()
3433                                       .fetchByG_T_Last(groupId, templateId, orderByComparator);
3434            }
3435    
3436            /**
3437            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
3438            *
3439            * @param id the primary key of the current journal article
3440            * @param groupId the group ID
3441            * @param templateId the template ID
3442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3443            * @return the previous, current, and next journal article
3444            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3445            */
3446            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
3447                    long id, long groupId, java.lang.String templateId,
3448                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3449                    throws com.liferay.portlet.journal.NoSuchArticleException {
3450                    return getPersistence()
3451                                       .findByG_T_PrevAndNext(id, groupId, templateId,
3452                            orderByComparator);
3453            }
3454    
3455            /**
3456            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3457            *
3458            * @param groupId the group ID
3459            * @param templateId the template ID
3460            * @return the matching journal articles that the user has permission to view
3461            */
3462            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3463                    long groupId, java.lang.String templateId) {
3464                    return getPersistence().filterFindByG_T(groupId, templateId);
3465            }
3466    
3467            /**
3468            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3469            *
3470            * <p>
3471            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3472            * </p>
3473            *
3474            * @param groupId the group ID
3475            * @param templateId the template ID
3476            * @param start the lower bound of the range of journal articles
3477            * @param end the upper bound of the range of journal articles (not inclusive)
3478            * @return the range of matching journal articles that the user has permission to view
3479            */
3480            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3481                    long groupId, java.lang.String templateId, int start, int end) {
3482                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
3483            }
3484    
3485            /**
3486            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
3487            *
3488            * <p>
3489            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3490            * </p>
3491            *
3492            * @param groupId the group ID
3493            * @param templateId the template ID
3494            * @param start the lower bound of the range of journal articles
3495            * @param end the upper bound of the range of journal articles (not inclusive)
3496            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3497            * @return the ordered range of matching journal articles that the user has permission to view
3498            */
3499            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
3500                    long groupId, java.lang.String templateId, int start, int end,
3501                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3502                    return getPersistence()
3503                                       .filterFindByG_T(groupId, templateId, start, end,
3504                            orderByComparator);
3505            }
3506    
3507            /**
3508            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3509            *
3510            * @param id the primary key of the current journal article
3511            * @param groupId the group ID
3512            * @param templateId the template ID
3513            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3514            * @return the previous, current, and next journal article
3515            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3516            */
3517            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
3518                    long id, long groupId, java.lang.String templateId,
3519                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3520                    throws com.liferay.portlet.journal.NoSuchArticleException {
3521                    return getPersistence()
3522                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
3523                            orderByComparator);
3524            }
3525    
3526            /**
3527            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
3528            *
3529            * @param groupId the group ID
3530            * @param templateId the template ID
3531            */
3532            public static void removeByG_T(long groupId, java.lang.String templateId) {
3533                    getPersistence().removeByG_T(groupId, templateId);
3534            }
3535    
3536            /**
3537            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
3538            *
3539            * @param groupId the group ID
3540            * @param templateId the template ID
3541            * @return the number of matching journal articles
3542            */
3543            public static int countByG_T(long groupId, java.lang.String templateId) {
3544                    return getPersistence().countByG_T(groupId, templateId);
3545            }
3546    
3547            /**
3548            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
3549            *
3550            * @param groupId the group ID
3551            * @param templateId the template ID
3552            * @return the number of matching journal articles that the user has permission to view
3553            */
3554            public static int filterCountByG_T(long groupId, java.lang.String templateId) {
3555                    return getPersistence().filterCountByG_T(groupId, templateId);
3556            }
3557    
3558            /**
3559            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3560            *
3561            * @param groupId the group ID
3562            * @param layoutUuid the layout uuid
3563            * @return the matching journal articles
3564            */
3565            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3566                    long groupId, java.lang.String layoutUuid) {
3567                    return getPersistence().findByG_L(groupId, layoutUuid);
3568            }
3569    
3570            /**
3571            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3572            *
3573            * <p>
3574            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3575            * </p>
3576            *
3577            * @param groupId the group ID
3578            * @param layoutUuid the layout uuid
3579            * @param start the lower bound of the range of journal articles
3580            * @param end the upper bound of the range of journal articles (not inclusive)
3581            * @return the range of matching journal articles
3582            */
3583            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3584                    long groupId, java.lang.String layoutUuid, int start, int end) {
3585                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
3586            }
3587    
3588            /**
3589            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3590            *
3591            * <p>
3592            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3593            * </p>
3594            *
3595            * @param groupId the group ID
3596            * @param layoutUuid the layout uuid
3597            * @param start the lower bound of the range of journal articles
3598            * @param end the upper bound of the range of journal articles (not inclusive)
3599            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3600            * @return the ordered range of matching journal articles
3601            */
3602            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
3603                    long groupId, java.lang.String layoutUuid, int start, int end,
3604                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3605                    return getPersistence()
3606                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
3607            }
3608    
3609            /**
3610            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3611            *
3612            * @param groupId the group ID
3613            * @param layoutUuid the layout uuid
3614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3615            * @return the first matching journal article
3616            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3617            */
3618            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
3619                    long groupId, java.lang.String layoutUuid,
3620                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3621                    throws com.liferay.portlet.journal.NoSuchArticleException {
3622                    return getPersistence()
3623                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
3624            }
3625    
3626            /**
3627            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3628            *
3629            * @param groupId the group ID
3630            * @param layoutUuid the layout uuid
3631            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3632            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3633            */
3634            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First(
3635                    long groupId, java.lang.String layoutUuid,
3636                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3637                    return getPersistence()
3638                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
3639            }
3640    
3641            /**
3642            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3643            *
3644            * @param groupId the group ID
3645            * @param layoutUuid the layout uuid
3646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3647            * @return the last matching journal article
3648            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3649            */
3650            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
3651                    long groupId, java.lang.String layoutUuid,
3652                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3653                    throws com.liferay.portlet.journal.NoSuchArticleException {
3654                    return getPersistence()
3655                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
3656            }
3657    
3658            /**
3659            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3660            *
3661            * @param groupId the group ID
3662            * @param layoutUuid the layout uuid
3663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3664            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3665            */
3666            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last(
3667                    long groupId, java.lang.String layoutUuid,
3668                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3669                    return getPersistence()
3670                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
3671            }
3672    
3673            /**
3674            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3675            *
3676            * @param id the primary key of the current journal article
3677            * @param groupId the group ID
3678            * @param layoutUuid the layout uuid
3679            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3680            * @return the previous, current, and next journal article
3681            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3682            */
3683            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
3684                    long id, long groupId, java.lang.String layoutUuid,
3685                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3686                    throws com.liferay.portlet.journal.NoSuchArticleException {
3687                    return getPersistence()
3688                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
3689                            orderByComparator);
3690            }
3691    
3692            /**
3693            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3694            *
3695            * @param groupId the group ID
3696            * @param layoutUuid the layout uuid
3697            * @return the matching journal articles that the user has permission to view
3698            */
3699            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3700                    long groupId, java.lang.String layoutUuid) {
3701                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
3702            }
3703    
3704            /**
3705            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3706            *
3707            * <p>
3708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3709            * </p>
3710            *
3711            * @param groupId the group ID
3712            * @param layoutUuid the layout uuid
3713            * @param start the lower bound of the range of journal articles
3714            * @param end the upper bound of the range of journal articles (not inclusive)
3715            * @return the range of matching journal articles that the user has permission to view
3716            */
3717            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3718                    long groupId, java.lang.String layoutUuid, int start, int end) {
3719                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
3720            }
3721    
3722            /**
3723            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
3724            *
3725            * <p>
3726            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3727            * </p>
3728            *
3729            * @param groupId the group ID
3730            * @param layoutUuid the layout uuid
3731            * @param start the lower bound of the range of journal articles
3732            * @param end the upper bound of the range of journal articles (not inclusive)
3733            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3734            * @return the ordered range of matching journal articles that the user has permission to view
3735            */
3736            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
3737                    long groupId, java.lang.String layoutUuid, int start, int end,
3738                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3739                    return getPersistence()
3740                                       .filterFindByG_L(groupId, layoutUuid, start, end,
3741                            orderByComparator);
3742            }
3743    
3744            /**
3745            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3746            *
3747            * @param id the primary key of the current journal article
3748            * @param groupId the group ID
3749            * @param layoutUuid the layout uuid
3750            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3751            * @return the previous, current, and next journal article
3752            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3753            */
3754            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
3755                    long id, long groupId, java.lang.String layoutUuid,
3756                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3757                    throws com.liferay.portlet.journal.NoSuchArticleException {
3758                    return getPersistence()
3759                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
3760                            orderByComparator);
3761            }
3762    
3763            /**
3764            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
3765            *
3766            * @param groupId the group ID
3767            * @param layoutUuid the layout uuid
3768            */
3769            public static void removeByG_L(long groupId, java.lang.String layoutUuid) {
3770                    getPersistence().removeByG_L(groupId, layoutUuid);
3771            }
3772    
3773            /**
3774            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
3775            *
3776            * @param groupId the group ID
3777            * @param layoutUuid the layout uuid
3778            * @return the number of matching journal articles
3779            */
3780            public static int countByG_L(long groupId, java.lang.String layoutUuid) {
3781                    return getPersistence().countByG_L(groupId, layoutUuid);
3782            }
3783    
3784            /**
3785            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3786            *
3787            * @param groupId the group ID
3788            * @param layoutUuid the layout uuid
3789            * @return the number of matching journal articles that the user has permission to view
3790            */
3791            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) {
3792                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
3793            }
3794    
3795            /**
3796            * Returns all the journal articles where groupId = &#63; and status = &#63;.
3797            *
3798            * @param groupId the group ID
3799            * @param status the status
3800            * @return the matching journal articles
3801            */
3802            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
3803                    long groupId, int status) {
3804                    return getPersistence().findByG_ST(groupId, status);
3805            }
3806    
3807            /**
3808            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
3809            *
3810            * <p>
3811            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3812            * </p>
3813            *
3814            * @param groupId the group ID
3815            * @param status the status
3816            * @param start the lower bound of the range of journal articles
3817            * @param end the upper bound of the range of journal articles (not inclusive)
3818            * @return the range of matching journal articles
3819            */
3820            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
3821                    long groupId, int status, int start, int end) {
3822                    return getPersistence().findByG_ST(groupId, status, start, end);
3823            }
3824    
3825            /**
3826            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
3827            *
3828            * <p>
3829            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3830            * </p>
3831            *
3832            * @param groupId the group ID
3833            * @param status the status
3834            * @param start the lower bound of the range of journal articles
3835            * @param end the upper bound of the range of journal articles (not inclusive)
3836            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3837            * @return the ordered range of matching journal articles
3838            */
3839            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
3840                    long groupId, int status, int start, int end,
3841                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3842                    return getPersistence()
3843                                       .findByG_ST(groupId, status, start, end, orderByComparator);
3844            }
3845    
3846            /**
3847            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
3848            *
3849            * @param groupId the group ID
3850            * @param status the status
3851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3852            * @return the first matching journal article
3853            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3854            */
3855            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
3856                    long groupId, int status,
3857                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3858                    throws com.liferay.portlet.journal.NoSuchArticleException {
3859                    return getPersistence()
3860                                       .findByG_ST_First(groupId, status, orderByComparator);
3861            }
3862    
3863            /**
3864            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
3865            *
3866            * @param groupId the group ID
3867            * @param status the status
3868            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3869            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3870            */
3871            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First(
3872                    long groupId, int status,
3873                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3874                    return getPersistence()
3875                                       .fetchByG_ST_First(groupId, status, orderByComparator);
3876            }
3877    
3878            /**
3879            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
3880            *
3881            * @param groupId the group ID
3882            * @param status the status
3883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3884            * @return the last matching journal article
3885            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3886            */
3887            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
3888                    long groupId, int status,
3889                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3890                    throws com.liferay.portlet.journal.NoSuchArticleException {
3891                    return getPersistence()
3892                                       .findByG_ST_Last(groupId, status, orderByComparator);
3893            }
3894    
3895            /**
3896            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
3897            *
3898            * @param groupId the group ID
3899            * @param status the status
3900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3901            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3902            */
3903            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last(
3904                    long groupId, int status,
3905                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3906                    return getPersistence()
3907                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
3908            }
3909    
3910            /**
3911            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
3912            *
3913            * @param id the primary key of the current journal article
3914            * @param groupId the group ID
3915            * @param status the status
3916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3917            * @return the previous, current, and next journal article
3918            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3919            */
3920            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
3921                    long id, long groupId, int status,
3922                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3923                    throws com.liferay.portlet.journal.NoSuchArticleException {
3924                    return getPersistence()
3925                                       .findByG_ST_PrevAndNext(id, groupId, status,
3926                            orderByComparator);
3927            }
3928    
3929            /**
3930            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3931            *
3932            * @param groupId the group ID
3933            * @param status the status
3934            * @return the matching journal articles that the user has permission to view
3935            */
3936            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
3937                    long groupId, int status) {
3938                    return getPersistence().filterFindByG_ST(groupId, status);
3939            }
3940    
3941            /**
3942            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3943            *
3944            * <p>
3945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3946            * </p>
3947            *
3948            * @param groupId the group ID
3949            * @param status the status
3950            * @param start the lower bound of the range of journal articles
3951            * @param end the upper bound of the range of journal articles (not inclusive)
3952            * @return the range of matching journal articles that the user has permission to view
3953            */
3954            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
3955                    long groupId, int status, int start, int end) {
3956                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
3957            }
3958    
3959            /**
3960            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
3961            *
3962            * <p>
3963            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
3964            * </p>
3965            *
3966            * @param groupId the group ID
3967            * @param status the status
3968            * @param start the lower bound of the range of journal articles
3969            * @param end the upper bound of the range of journal articles (not inclusive)
3970            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3971            * @return the ordered range of matching journal articles that the user has permission to view
3972            */
3973            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
3974                    long groupId, int status, int start, int end,
3975                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
3976                    return getPersistence()
3977                                       .filterFindByG_ST(groupId, status, start, end,
3978                            orderByComparator);
3979            }
3980    
3981            /**
3982            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3983            *
3984            * @param id the primary key of the current journal article
3985            * @param groupId the group ID
3986            * @param status the status
3987            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3988            * @return the previous, current, and next journal article
3989            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3990            */
3991            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
3992                    long id, long groupId, int status,
3993                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
3994                    throws com.liferay.portlet.journal.NoSuchArticleException {
3995                    return getPersistence()
3996                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
3997                            orderByComparator);
3998            }
3999    
4000            /**
4001            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4002            *
4003            * @param groupId the group ID
4004            * @param status the status
4005            */
4006            public static void removeByG_ST(long groupId, int status) {
4007                    getPersistence().removeByG_ST(groupId, status);
4008            }
4009    
4010            /**
4011            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4012            *
4013            * @param groupId the group ID
4014            * @param status the status
4015            * @return the number of matching journal articles
4016            */
4017            public static int countByG_ST(long groupId, int status) {
4018                    return getPersistence().countByG_ST(groupId, status);
4019            }
4020    
4021            /**
4022            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4023            *
4024            * @param groupId the group ID
4025            * @param status the status
4026            * @return the number of matching journal articles that the user has permission to view
4027            */
4028            public static int filterCountByG_ST(long groupId, int status) {
4029                    return getPersistence().filterCountByG_ST(groupId, status);
4030            }
4031    
4032            /**
4033            * Returns all the journal articles where companyId = &#63; and version = &#63;.
4034            *
4035            * @param companyId the company ID
4036            * @param version the version
4037            * @return the matching journal articles
4038            */
4039            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4040                    long companyId, double version) {
4041                    return getPersistence().findByC_V(companyId, version);
4042            }
4043    
4044            /**
4045            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4046            *
4047            * <p>
4048            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4049            * </p>
4050            *
4051            * @param companyId the company ID
4052            * @param version the version
4053            * @param start the lower bound of the range of journal articles
4054            * @param end the upper bound of the range of journal articles (not inclusive)
4055            * @return the range of matching journal articles
4056            */
4057            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4058                    long companyId, double version, int start, int end) {
4059                    return getPersistence().findByC_V(companyId, version, start, end);
4060            }
4061    
4062            /**
4063            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
4064            *
4065            * <p>
4066            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4067            * </p>
4068            *
4069            * @param companyId the company ID
4070            * @param version the version
4071            * @param start the lower bound of the range of journal articles
4072            * @param end the upper bound of the range of journal articles (not inclusive)
4073            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4074            * @return the ordered range of matching journal articles
4075            */
4076            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
4077                    long companyId, double version, int start, int end,
4078                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4079                    return getPersistence()
4080                                       .findByC_V(companyId, version, start, end, orderByComparator);
4081            }
4082    
4083            /**
4084            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4085            *
4086            * @param companyId the company ID
4087            * @param version the version
4088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4089            * @return the first matching journal article
4090            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4091            */
4092            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
4093                    long companyId, double version,
4094                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4095                    throws com.liferay.portlet.journal.NoSuchArticleException {
4096                    return getPersistence()
4097                                       .findByC_V_First(companyId, version, orderByComparator);
4098            }
4099    
4100            /**
4101            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4102            *
4103            * @param companyId the company ID
4104            * @param version the version
4105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4106            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4107            */
4108            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First(
4109                    long companyId, double version,
4110                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4111                    return getPersistence()
4112                                       .fetchByC_V_First(companyId, version, orderByComparator);
4113            }
4114    
4115            /**
4116            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4117            *
4118            * @param companyId the company ID
4119            * @param version the version
4120            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4121            * @return the last matching journal article
4122            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4123            */
4124            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
4125                    long companyId, double version,
4126                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4127                    throws com.liferay.portlet.journal.NoSuchArticleException {
4128                    return getPersistence()
4129                                       .findByC_V_Last(companyId, version, orderByComparator);
4130            }
4131    
4132            /**
4133            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4134            *
4135            * @param companyId the company ID
4136            * @param version the version
4137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4138            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4139            */
4140            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last(
4141                    long companyId, double version,
4142                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4143                    return getPersistence()
4144                                       .fetchByC_V_Last(companyId, version, orderByComparator);
4145            }
4146    
4147            /**
4148            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
4149            *
4150            * @param id the primary key of the current journal article
4151            * @param companyId the company ID
4152            * @param version the version
4153            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4154            * @return the previous, current, and next journal article
4155            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4156            */
4157            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
4158                    long id, long companyId, double version,
4159                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4160                    throws com.liferay.portlet.journal.NoSuchArticleException {
4161                    return getPersistence()
4162                                       .findByC_V_PrevAndNext(id, companyId, version,
4163                            orderByComparator);
4164            }
4165    
4166            /**
4167            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4168            *
4169            * @param companyId the company ID
4170            * @param version the version
4171            */
4172            public static void removeByC_V(long companyId, double version) {
4173                    getPersistence().removeByC_V(companyId, version);
4174            }
4175    
4176            /**
4177            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4178            *
4179            * @param companyId the company ID
4180            * @param version the version
4181            * @return the number of matching journal articles
4182            */
4183            public static int countByC_V(long companyId, double version) {
4184                    return getPersistence().countByC_V(companyId, version);
4185            }
4186    
4187            /**
4188            * Returns all the journal articles where companyId = &#63; and status = &#63;.
4189            *
4190            * @param companyId the company ID
4191            * @param status the status
4192            * @return the matching journal articles
4193            */
4194            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4195                    long companyId, int status) {
4196                    return getPersistence().findByC_ST(companyId, status);
4197            }
4198    
4199            /**
4200            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
4201            *
4202            * <p>
4203            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4204            * </p>
4205            *
4206            * @param companyId the company ID
4207            * @param status the status
4208            * @param start the lower bound of the range of journal articles
4209            * @param end the upper bound of the range of journal articles (not inclusive)
4210            * @return the range of matching journal articles
4211            */
4212            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4213                    long companyId, int status, int start, int end) {
4214                    return getPersistence().findByC_ST(companyId, status, start, end);
4215            }
4216    
4217            /**
4218            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
4219            *
4220            * <p>
4221            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4222            * </p>
4223            *
4224            * @param companyId the company ID
4225            * @param status the status
4226            * @param start the lower bound of the range of journal articles
4227            * @param end the upper bound of the range of journal articles (not inclusive)
4228            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4229            * @return the ordered range of matching journal articles
4230            */
4231            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
4232                    long companyId, int status, int start, int end,
4233                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4234                    return getPersistence()
4235                                       .findByC_ST(companyId, status, start, end, orderByComparator);
4236            }
4237    
4238            /**
4239            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4240            *
4241            * @param companyId the company ID
4242            * @param status the status
4243            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4244            * @return the first matching journal article
4245            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4246            */
4247            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
4248                    long companyId, int status,
4249                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4250                    throws com.liferay.portlet.journal.NoSuchArticleException {
4251                    return getPersistence()
4252                                       .findByC_ST_First(companyId, status, orderByComparator);
4253            }
4254    
4255            /**
4256            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4257            *
4258            * @param companyId the company ID
4259            * @param status the status
4260            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4261            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4262            */
4263            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First(
4264                    long companyId, int status,
4265                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4266                    return getPersistence()
4267                                       .fetchByC_ST_First(companyId, status, orderByComparator);
4268            }
4269    
4270            /**
4271            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4272            *
4273            * @param companyId the company ID
4274            * @param status the status
4275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4276            * @return the last matching journal article
4277            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4278            */
4279            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
4280                    long companyId, int status,
4281                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4282                    throws com.liferay.portlet.journal.NoSuchArticleException {
4283                    return getPersistence()
4284                                       .findByC_ST_Last(companyId, status, orderByComparator);
4285            }
4286    
4287            /**
4288            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4289            *
4290            * @param companyId the company ID
4291            * @param status the status
4292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4293            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4294            */
4295            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last(
4296                    long companyId, int status,
4297                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4298                    return getPersistence()
4299                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
4300            }
4301    
4302            /**
4303            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
4304            *
4305            * @param id the primary key of the current journal article
4306            * @param companyId the company ID
4307            * @param status the status
4308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4309            * @return the previous, current, and next journal article
4310            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4311            */
4312            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
4313                    long id, long companyId, int status,
4314                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4315                    throws com.liferay.portlet.journal.NoSuchArticleException {
4316                    return getPersistence()
4317                                       .findByC_ST_PrevAndNext(id, companyId, status,
4318                            orderByComparator);
4319            }
4320    
4321            /**
4322            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4323            *
4324            * @param companyId the company ID
4325            * @param status the status
4326            */
4327            public static void removeByC_ST(long companyId, int status) {
4328                    getPersistence().removeByC_ST(companyId, status);
4329            }
4330    
4331            /**
4332            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4333            *
4334            * @param companyId the company ID
4335            * @param status the status
4336            * @return the number of matching journal articles
4337            */
4338            public static int countByC_ST(long companyId, int status) {
4339                    return getPersistence().countByC_ST(companyId, status);
4340            }
4341    
4342            /**
4343            * Returns all the journal articles where companyId = &#63; and status &ne; &#63;.
4344            *
4345            * @param companyId the company ID
4346            * @param status the status
4347            * @return the matching journal articles
4348            */
4349            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4350                    long companyId, int status) {
4351                    return getPersistence().findByC_NotST(companyId, status);
4352            }
4353    
4354            /**
4355            * Returns a range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4356            *
4357            * <p>
4358            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4359            * </p>
4360            *
4361            * @param companyId the company ID
4362            * @param status the status
4363            * @param start the lower bound of the range of journal articles
4364            * @param end the upper bound of the range of journal articles (not inclusive)
4365            * @return the range of matching journal articles
4366            */
4367            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4368                    long companyId, int status, int start, int end) {
4369                    return getPersistence().findByC_NotST(companyId, status, start, end);
4370            }
4371    
4372            /**
4373            * Returns an ordered range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4374            *
4375            * <p>
4376            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4377            * </p>
4378            *
4379            * @param companyId the company ID
4380            * @param status the status
4381            * @param start the lower bound of the range of journal articles
4382            * @param end the upper bound of the range of journal articles (not inclusive)
4383            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4384            * @return the ordered range of matching journal articles
4385            */
4386            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST(
4387                    long companyId, int status, int start, int end,
4388                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4389                    return getPersistence()
4390                                       .findByC_NotST(companyId, status, start, end,
4391                            orderByComparator);
4392            }
4393    
4394            /**
4395            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4396            *
4397            * @param companyId the company ID
4398            * @param status the status
4399            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4400            * @return the first matching journal article
4401            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4402            */
4403            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First(
4404                    long companyId, int status,
4405                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4406                    throws com.liferay.portlet.journal.NoSuchArticleException {
4407                    return getPersistence()
4408                                       .findByC_NotST_First(companyId, status, orderByComparator);
4409            }
4410    
4411            /**
4412            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4413            *
4414            * @param companyId the company ID
4415            * @param status the status
4416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4417            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4418            */
4419            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First(
4420                    long companyId, int status,
4421                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4422                    return getPersistence()
4423                                       .fetchByC_NotST_First(companyId, status, orderByComparator);
4424            }
4425    
4426            /**
4427            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4428            *
4429            * @param companyId the company ID
4430            * @param status the status
4431            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4432            * @return the last matching journal article
4433            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4434            */
4435            public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last(
4436                    long companyId, int status,
4437                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4438                    throws com.liferay.portlet.journal.NoSuchArticleException {
4439                    return getPersistence()
4440                                       .findByC_NotST_Last(companyId, status, orderByComparator);
4441            }
4442    
4443            /**
4444            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4445            *
4446            * @param companyId the company ID
4447            * @param status the status
4448            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4449            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4450            */
4451            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last(
4452                    long companyId, int status,
4453                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4454                    return getPersistence()
4455                                       .fetchByC_NotST_Last(companyId, status, orderByComparator);
4456            }
4457    
4458            /**
4459            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4460            *
4461            * @param id the primary key of the current journal article
4462            * @param companyId the company ID
4463            * @param status the status
4464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4465            * @return the previous, current, and next journal article
4466            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4467            */
4468            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext(
4469                    long id, long companyId, int status,
4470                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4471                    throws com.liferay.portlet.journal.NoSuchArticleException {
4472                    return getPersistence()
4473                                       .findByC_NotST_PrevAndNext(id, companyId, status,
4474                            orderByComparator);
4475            }
4476    
4477            /**
4478            * Removes all the journal articles where companyId = &#63; and status &ne; &#63; from the database.
4479            *
4480            * @param companyId the company ID
4481            * @param status the status
4482            */
4483            public static void removeByC_NotST(long companyId, int status) {
4484                    getPersistence().removeByC_NotST(companyId, status);
4485            }
4486    
4487            /**
4488            * Returns the number of journal articles where companyId = &#63; and status &ne; &#63;.
4489            *
4490            * @param companyId the company ID
4491            * @param status the status
4492            * @return the number of matching journal articles
4493            */
4494            public static int countByC_NotST(long companyId, int status) {
4495                    return getPersistence().countByC_NotST(companyId, status);
4496            }
4497    
4498            /**
4499            * Returns all the journal articles where classNameId = &#63; and templateId = &#63;.
4500            *
4501            * @param classNameId the class name ID
4502            * @param templateId the template ID
4503            * @return the matching journal articles
4504            */
4505            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
4506                    long classNameId, java.lang.String templateId) {
4507                    return getPersistence().findByC_T(classNameId, templateId);
4508            }
4509    
4510            /**
4511            * Returns a range of all the journal articles where classNameId = &#63; and templateId = &#63;.
4512            *
4513            * <p>
4514            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4515            * </p>
4516            *
4517            * @param classNameId the class name ID
4518            * @param templateId the template ID
4519            * @param start the lower bound of the range of journal articles
4520            * @param end the upper bound of the range of journal articles (not inclusive)
4521            * @return the range of matching journal articles
4522            */
4523            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
4524                    long classNameId, java.lang.String templateId, int start, int end) {
4525                    return getPersistence().findByC_T(classNameId, templateId, start, end);
4526            }
4527    
4528            /**
4529            * Returns an ordered range of all the journal articles where classNameId = &#63; and templateId = &#63;.
4530            *
4531            * <p>
4532            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4533            * </p>
4534            *
4535            * @param classNameId the class name ID
4536            * @param templateId the template ID
4537            * @param start the lower bound of the range of journal articles
4538            * @param end the upper bound of the range of journal articles (not inclusive)
4539            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4540            * @return the ordered range of matching journal articles
4541            */
4542            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T(
4543                    long classNameId, java.lang.String templateId, int start, int end,
4544                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4545                    return getPersistence()
4546                                       .findByC_T(classNameId, templateId, start, end,
4547                            orderByComparator);
4548            }
4549    
4550            /**
4551            * Returns the first journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
4552            *
4553            * @param classNameId the class name ID
4554            * @param templateId the template ID
4555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4556            * @return the first matching journal article
4557            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4558            */
4559            public static com.liferay.portlet.journal.model.JournalArticle findByC_T_First(
4560                    long classNameId, java.lang.String templateId,
4561                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4562                    throws com.liferay.portlet.journal.NoSuchArticleException {
4563                    return getPersistence()
4564                                       .findByC_T_First(classNameId, templateId, orderByComparator);
4565            }
4566    
4567            /**
4568            * Returns the first journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
4569            *
4570            * @param classNameId the class name ID
4571            * @param templateId the template ID
4572            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4573            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4574            */
4575            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_First(
4576                    long classNameId, java.lang.String templateId,
4577                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4578                    return getPersistence()
4579                                       .fetchByC_T_First(classNameId, templateId, orderByComparator);
4580            }
4581    
4582            /**
4583            * Returns the last journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
4584            *
4585            * @param classNameId the class name ID
4586            * @param templateId the template ID
4587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4588            * @return the last matching journal article
4589            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4590            */
4591            public static com.liferay.portlet.journal.model.JournalArticle findByC_T_Last(
4592                    long classNameId, java.lang.String templateId,
4593                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4594                    throws com.liferay.portlet.journal.NoSuchArticleException {
4595                    return getPersistence()
4596                                       .findByC_T_Last(classNameId, templateId, orderByComparator);
4597            }
4598    
4599            /**
4600            * Returns the last journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
4601            *
4602            * @param classNameId the class name ID
4603            * @param templateId the template ID
4604            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4605            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4606            */
4607            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_Last(
4608                    long classNameId, java.lang.String templateId,
4609                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4610                    return getPersistence()
4611                                       .fetchByC_T_Last(classNameId, templateId, orderByComparator);
4612            }
4613    
4614            /**
4615            * Returns the journal articles before and after the current journal article in the ordered set where classNameId = &#63; and templateId = &#63;.
4616            *
4617            * @param id the primary key of the current journal article
4618            * @param classNameId the class name ID
4619            * @param templateId the template ID
4620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4621            * @return the previous, current, and next journal article
4622            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4623            */
4624            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_T_PrevAndNext(
4625                    long id, long classNameId, java.lang.String templateId,
4626                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4627                    throws com.liferay.portlet.journal.NoSuchArticleException {
4628                    return getPersistence()
4629                                       .findByC_T_PrevAndNext(id, classNameId, templateId,
4630                            orderByComparator);
4631            }
4632    
4633            /**
4634            * Removes all the journal articles where classNameId = &#63; and templateId = &#63; from the database.
4635            *
4636            * @param classNameId the class name ID
4637            * @param templateId the template ID
4638            */
4639            public static void removeByC_T(long classNameId, java.lang.String templateId) {
4640                    getPersistence().removeByC_T(classNameId, templateId);
4641            }
4642    
4643            /**
4644            * Returns the number of journal articles where classNameId = &#63; and templateId = &#63;.
4645            *
4646            * @param classNameId the class name ID
4647            * @param templateId the template ID
4648            * @return the number of matching journal articles
4649            */
4650            public static int countByC_T(long classNameId, java.lang.String templateId) {
4651                    return getPersistence().countByC_T(classNameId, templateId);
4652            }
4653    
4654            /**
4655            * Returns all the journal articles where displayDate &lt; &#63; and status = &#63;.
4656            *
4657            * @param displayDate the display date
4658            * @param status the status
4659            * @return the matching journal articles
4660            */
4661            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
4662                    java.util.Date displayDate, int status) {
4663                    return getPersistence().findByLtD_S(displayDate, status);
4664            }
4665    
4666            /**
4667            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
4668            *
4669            * <p>
4670            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4671            * </p>
4672            *
4673            * @param displayDate the display date
4674            * @param status the status
4675            * @param start the lower bound of the range of journal articles
4676            * @param end the upper bound of the range of journal articles (not inclusive)
4677            * @return the range of matching journal articles
4678            */
4679            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
4680                    java.util.Date displayDate, int status, int start, int end) {
4681                    return getPersistence().findByLtD_S(displayDate, status, start, end);
4682            }
4683    
4684            /**
4685            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
4686            *
4687            * <p>
4688            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4689            * </p>
4690            *
4691            * @param displayDate the display date
4692            * @param status the status
4693            * @param start the lower bound of the range of journal articles
4694            * @param end the upper bound of the range of journal articles (not inclusive)
4695            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4696            * @return the ordered range of matching journal articles
4697            */
4698            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S(
4699                    java.util.Date displayDate, int status, int start, int end,
4700                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4701                    return getPersistence()
4702                                       .findByLtD_S(displayDate, status, start, end,
4703                            orderByComparator);
4704            }
4705    
4706            /**
4707            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4708            *
4709            * @param displayDate the display date
4710            * @param status the status
4711            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4712            * @return the first matching journal article
4713            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4714            */
4715            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First(
4716                    java.util.Date displayDate, int status,
4717                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4718                    throws com.liferay.portlet.journal.NoSuchArticleException {
4719                    return getPersistence()
4720                                       .findByLtD_S_First(displayDate, status, orderByComparator);
4721            }
4722    
4723            /**
4724            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4725            *
4726            * @param displayDate the display date
4727            * @param status the status
4728            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4729            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4730            */
4731            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First(
4732                    java.util.Date displayDate, int status,
4733                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4734                    return getPersistence()
4735                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
4736            }
4737    
4738            /**
4739            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4740            *
4741            * @param displayDate the display date
4742            * @param status the status
4743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4744            * @return the last matching journal article
4745            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4746            */
4747            public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last(
4748                    java.util.Date displayDate, int status,
4749                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4750                    throws com.liferay.portlet.journal.NoSuchArticleException {
4751                    return getPersistence()
4752                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
4753            }
4754    
4755            /**
4756            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4757            *
4758            * @param displayDate the display date
4759            * @param status the status
4760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4761            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4762            */
4763            public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last(
4764                    java.util.Date displayDate, int status,
4765                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4766                    return getPersistence()
4767                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
4768            }
4769    
4770            /**
4771            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4772            *
4773            * @param id the primary key of the current journal article
4774            * @param displayDate the display date
4775            * @param status the status
4776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4777            * @return the previous, current, and next journal article
4778            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4779            */
4780            public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext(
4781                    long id, java.util.Date displayDate, int status,
4782                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4783                    throws com.liferay.portlet.journal.NoSuchArticleException {
4784                    return getPersistence()
4785                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
4786                            orderByComparator);
4787            }
4788    
4789            /**
4790            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
4791            *
4792            * @param displayDate the display date
4793            * @param status the status
4794            */
4795            public static void removeByLtD_S(java.util.Date displayDate, int status) {
4796                    getPersistence().removeByLtD_S(displayDate, status);
4797            }
4798    
4799            /**
4800            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
4801            *
4802            * @param displayDate the display date
4803            * @param status the status
4804            * @return the number of matching journal articles
4805            */
4806            public static int countByLtD_S(java.util.Date displayDate, int status) {
4807                    return getPersistence().countByLtD_S(displayDate, status);
4808            }
4809    
4810            /**
4811            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4812            *
4813            * @param resourcePrimKey the resource prim key
4814            * @param indexable the indexable
4815            * @param status the status
4816            * @return the matching journal articles
4817            */
4818            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4819                    long resourcePrimKey, boolean indexable, int status) {
4820                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
4821            }
4822    
4823            /**
4824            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4825            *
4826            * <p>
4827            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4828            * </p>
4829            *
4830            * @param resourcePrimKey the resource prim key
4831            * @param indexable the indexable
4832            * @param status the status
4833            * @param start the lower bound of the range of journal articles
4834            * @param end the upper bound of the range of journal articles (not inclusive)
4835            * @return the range of matching journal articles
4836            */
4837            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4838                    long resourcePrimKey, boolean indexable, int status, int start, int end) {
4839                    return getPersistence()
4840                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
4841            }
4842    
4843            /**
4844            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4845            *
4846            * <p>
4847            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4848            * </p>
4849            *
4850            * @param resourcePrimKey the resource prim key
4851            * @param indexable the indexable
4852            * @param status the status
4853            * @param start the lower bound of the range of journal articles
4854            * @param end the upper bound of the range of journal articles (not inclusive)
4855            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4856            * @return the ordered range of matching journal articles
4857            */
4858            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4859                    long resourcePrimKey, boolean indexable, int status, int start,
4860                    int end,
4861                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4862                    return getPersistence()
4863                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
4864                            orderByComparator);
4865            }
4866    
4867            /**
4868            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4869            *
4870            * @param resourcePrimKey the resource prim key
4871            * @param indexable the indexable
4872            * @param status the status
4873            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4874            * @return the first matching journal article
4875            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4876            */
4877            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First(
4878                    long resourcePrimKey, boolean indexable, int status,
4879                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4880                    throws com.liferay.portlet.journal.NoSuchArticleException {
4881                    return getPersistence()
4882                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
4883                            orderByComparator);
4884            }
4885    
4886            /**
4887            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4888            *
4889            * @param resourcePrimKey the resource prim key
4890            * @param indexable the indexable
4891            * @param status the status
4892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4893            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4894            */
4895            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First(
4896                    long resourcePrimKey, boolean indexable, int status,
4897                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4898                    return getPersistence()
4899                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
4900                            orderByComparator);
4901            }
4902    
4903            /**
4904            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4905            *
4906            * @param resourcePrimKey the resource prim key
4907            * @param indexable the indexable
4908            * @param status the status
4909            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4910            * @return the last matching journal article
4911            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4912            */
4913            public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last(
4914                    long resourcePrimKey, boolean indexable, int status,
4915                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4916                    throws com.liferay.portlet.journal.NoSuchArticleException {
4917                    return getPersistence()
4918                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
4919                            orderByComparator);
4920            }
4921    
4922            /**
4923            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4924            *
4925            * @param resourcePrimKey the resource prim key
4926            * @param indexable the indexable
4927            * @param status the status
4928            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4929            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4930            */
4931            public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last(
4932                    long resourcePrimKey, boolean indexable, int status,
4933                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
4934                    return getPersistence()
4935                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
4936                            orderByComparator);
4937            }
4938    
4939            /**
4940            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4941            *
4942            * @param id the primary key of the current journal article
4943            * @param resourcePrimKey the resource prim key
4944            * @param indexable the indexable
4945            * @param status the status
4946            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4947            * @return the previous, current, and next journal article
4948            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4949            */
4950            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext(
4951                    long id, long resourcePrimKey, boolean indexable, int status,
4952                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
4953                    throws com.liferay.portlet.journal.NoSuchArticleException {
4954                    return getPersistence()
4955                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
4956                            status, orderByComparator);
4957            }
4958    
4959            /**
4960            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4961            *
4962            * <p>
4963            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4964            * </p>
4965            *
4966            * @param resourcePrimKey the resource prim key
4967            * @param indexable the indexable
4968            * @param statuses the statuses
4969            * @return the matching journal articles
4970            */
4971            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4972                    long resourcePrimKey, boolean indexable, int[] statuses) {
4973                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
4974            }
4975    
4976            /**
4977            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4978            *
4979            * <p>
4980            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
4981            * </p>
4982            *
4983            * @param resourcePrimKey the resource prim key
4984            * @param indexable the indexable
4985            * @param statuses the statuses
4986            * @param start the lower bound of the range of journal articles
4987            * @param end the upper bound of the range of journal articles (not inclusive)
4988            * @return the range of matching journal articles
4989            */
4990            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
4991                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
4992                    int end) {
4993                    return getPersistence()
4994                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
4995            }
4996    
4997            /**
4998            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4999            *
5000            * <p>
5001            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5002            * </p>
5003            *
5004            * @param resourcePrimKey the resource prim key
5005            * @param indexable the indexable
5006            * @param statuses the statuses
5007            * @param start the lower bound of the range of journal articles
5008            * @param end the upper bound of the range of journal articles (not inclusive)
5009            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5010            * @return the ordered range of matching journal articles
5011            */
5012            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S(
5013                    long resourcePrimKey, boolean indexable, int[] statuses, int start,
5014                    int end,
5015                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5016                    return getPersistence()
5017                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
5018                            end, orderByComparator);
5019            }
5020    
5021            /**
5022            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
5023            *
5024            * @param resourcePrimKey the resource prim key
5025            * @param indexable the indexable
5026            * @param status the status
5027            */
5028            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
5029                    int status) {
5030                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
5031            }
5032    
5033            /**
5034            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
5035            *
5036            * @param resourcePrimKey the resource prim key
5037            * @param indexable the indexable
5038            * @param status the status
5039            * @return the number of matching journal articles
5040            */
5041            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5042                    int status) {
5043                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
5044            }
5045    
5046            /**
5047            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
5048            *
5049            * @param resourcePrimKey the resource prim key
5050            * @param indexable the indexable
5051            * @param statuses the statuses
5052            * @return the number of matching journal articles
5053            */
5054            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5055                    int[] statuses) {
5056                    return getPersistence()
5057                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
5058            }
5059    
5060            /**
5061            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5062            *
5063            * @param groupId the group ID
5064            * @param userId the user ID
5065            * @param classNameId the class name ID
5066            * @return the matching journal articles
5067            */
5068            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5069                    long groupId, long userId, long classNameId) {
5070                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
5071            }
5072    
5073            /**
5074            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5075            *
5076            * <p>
5077            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5078            * </p>
5079            *
5080            * @param groupId the group ID
5081            * @param userId the user ID
5082            * @param classNameId the class name ID
5083            * @param start the lower bound of the range of journal articles
5084            * @param end the upper bound of the range of journal articles (not inclusive)
5085            * @return the range of matching journal articles
5086            */
5087            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5088                    long groupId, long userId, long classNameId, int start, int end) {
5089                    return getPersistence()
5090                                       .findByG_U_C(groupId, userId, classNameId, start, end);
5091            }
5092    
5093            /**
5094            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5095            *
5096            * <p>
5097            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5098            * </p>
5099            *
5100            * @param groupId the group ID
5101            * @param userId the user ID
5102            * @param classNameId the class name ID
5103            * @param start the lower bound of the range of journal articles
5104            * @param end the upper bound of the range of journal articles (not inclusive)
5105            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5106            * @return the ordered range of matching journal articles
5107            */
5108            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C(
5109                    long groupId, long userId, long classNameId, int start, int end,
5110                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5111                    return getPersistence()
5112                                       .findByG_U_C(groupId, userId, classNameId, start, end,
5113                            orderByComparator);
5114            }
5115    
5116            /**
5117            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5118            *
5119            * @param groupId the group ID
5120            * @param userId the user ID
5121            * @param classNameId the class name ID
5122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5123            * @return the first matching journal article
5124            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5125            */
5126            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First(
5127                    long groupId, long userId, long classNameId,
5128                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5129                    throws com.liferay.portlet.journal.NoSuchArticleException {
5130                    return getPersistence()
5131                                       .findByG_U_C_First(groupId, userId, classNameId,
5132                            orderByComparator);
5133            }
5134    
5135            /**
5136            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5137            *
5138            * @param groupId the group ID
5139            * @param userId the user ID
5140            * @param classNameId the class name ID
5141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5142            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5143            */
5144            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First(
5145                    long groupId, long userId, long classNameId,
5146                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5147                    return getPersistence()
5148                                       .fetchByG_U_C_First(groupId, userId, classNameId,
5149                            orderByComparator);
5150            }
5151    
5152            /**
5153            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5154            *
5155            * @param groupId the group ID
5156            * @param userId the user ID
5157            * @param classNameId the class name ID
5158            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5159            * @return the last matching journal article
5160            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5161            */
5162            public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last(
5163                    long groupId, long userId, long classNameId,
5164                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5165                    throws com.liferay.portlet.journal.NoSuchArticleException {
5166                    return getPersistence()
5167                                       .findByG_U_C_Last(groupId, userId, classNameId,
5168                            orderByComparator);
5169            }
5170    
5171            /**
5172            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5173            *
5174            * @param groupId the group ID
5175            * @param userId the user ID
5176            * @param classNameId the class name ID
5177            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5178            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5179            */
5180            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last(
5181                    long groupId, long userId, long classNameId,
5182                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5183                    return getPersistence()
5184                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
5185                            orderByComparator);
5186            }
5187    
5188            /**
5189            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5190            *
5191            * @param id the primary key of the current journal article
5192            * @param groupId the group ID
5193            * @param userId the user ID
5194            * @param classNameId the class name ID
5195            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5196            * @return the previous, current, and next journal article
5197            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5198            */
5199            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext(
5200                    long id, long groupId, long userId, long classNameId,
5201                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5202                    throws com.liferay.portlet.journal.NoSuchArticleException {
5203                    return getPersistence()
5204                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
5205                            orderByComparator);
5206            }
5207    
5208            /**
5209            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5210            *
5211            * @param groupId the group ID
5212            * @param userId the user ID
5213            * @param classNameId the class name ID
5214            * @return the matching journal articles that the user has permission to view
5215            */
5216            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5217                    long groupId, long userId, long classNameId) {
5218                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
5219            }
5220    
5221            /**
5222            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5223            *
5224            * <p>
5225            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5226            * </p>
5227            *
5228            * @param groupId the group ID
5229            * @param userId the user ID
5230            * @param classNameId the class name ID
5231            * @param start the lower bound of the range of journal articles
5232            * @param end the upper bound of the range of journal articles (not inclusive)
5233            * @return the range of matching journal articles that the user has permission to view
5234            */
5235            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5236                    long groupId, long userId, long classNameId, int start, int end) {
5237                    return getPersistence()
5238                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
5239            }
5240    
5241            /**
5242            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5243            *
5244            * <p>
5245            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5246            * </p>
5247            *
5248            * @param groupId the group ID
5249            * @param userId the user ID
5250            * @param classNameId the class name ID
5251            * @param start the lower bound of the range of journal articles
5252            * @param end the upper bound of the range of journal articles (not inclusive)
5253            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5254            * @return the ordered range of matching journal articles that the user has permission to view
5255            */
5256            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C(
5257                    long groupId, long userId, long classNameId, int start, int end,
5258                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5259                    return getPersistence()
5260                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
5261                            orderByComparator);
5262            }
5263    
5264            /**
5265            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5266            *
5267            * @param id the primary key of the current journal article
5268            * @param groupId the group ID
5269            * @param userId the user ID
5270            * @param classNameId the class name ID
5271            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5272            * @return the previous, current, and next journal article
5273            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5274            */
5275            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext(
5276                    long id, long groupId, long userId, long classNameId,
5277                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5278                    throws com.liferay.portlet.journal.NoSuchArticleException {
5279                    return getPersistence()
5280                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
5281                            classNameId, orderByComparator);
5282            }
5283    
5284            /**
5285            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
5286            *
5287            * @param groupId the group ID
5288            * @param userId the user ID
5289            * @param classNameId the class name ID
5290            */
5291            public static void removeByG_U_C(long groupId, long userId, long classNameId) {
5292                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
5293            }
5294    
5295            /**
5296            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5297            *
5298            * @param groupId the group ID
5299            * @param userId the user ID
5300            * @param classNameId the class name ID
5301            * @return the number of matching journal articles
5302            */
5303            public static int countByG_U_C(long groupId, long userId, long classNameId) {
5304                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
5305            }
5306    
5307            /**
5308            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5309            *
5310            * @param groupId the group ID
5311            * @param userId the user ID
5312            * @param classNameId the class name ID
5313            * @return the number of matching journal articles that the user has permission to view
5314            */
5315            public static int filterCountByG_U_C(long groupId, long userId,
5316                    long classNameId) {
5317                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
5318            }
5319    
5320            /**
5321            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5322            *
5323            * @param groupId the group ID
5324            * @param folderId the folder ID
5325            * @param status the status
5326            * @return the matching journal articles
5327            */
5328            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5329                    long groupId, long folderId, int status) {
5330                    return getPersistence().findByG_F_ST(groupId, folderId, status);
5331            }
5332    
5333            /**
5334            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5335            *
5336            * <p>
5337            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5338            * </p>
5339            *
5340            * @param groupId the group ID
5341            * @param folderId the folder ID
5342            * @param status the status
5343            * @param start the lower bound of the range of journal articles
5344            * @param end the upper bound of the range of journal articles (not inclusive)
5345            * @return the range of matching journal articles
5346            */
5347            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5348                    long groupId, long folderId, int status, int start, int end) {
5349                    return getPersistence()
5350                                       .findByG_F_ST(groupId, folderId, status, start, end);
5351            }
5352    
5353            /**
5354            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5355            *
5356            * <p>
5357            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5358            * </p>
5359            *
5360            * @param groupId the group ID
5361            * @param folderId the folder ID
5362            * @param status the status
5363            * @param start the lower bound of the range of journal articles
5364            * @param end the upper bound of the range of journal articles (not inclusive)
5365            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5366            * @return the ordered range of matching journal articles
5367            */
5368            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5369                    long groupId, long folderId, int status, int start, int end,
5370                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5371                    return getPersistence()
5372                                       .findByG_F_ST(groupId, folderId, status, start, end,
5373                            orderByComparator);
5374            }
5375    
5376            /**
5377            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5378            *
5379            * @param groupId the group ID
5380            * @param folderId the folder ID
5381            * @param status the status
5382            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5383            * @return the first matching journal article
5384            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5385            */
5386            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First(
5387                    long groupId, long folderId, int status,
5388                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5389                    throws com.liferay.portlet.journal.NoSuchArticleException {
5390                    return getPersistence()
5391                                       .findByG_F_ST_First(groupId, folderId, status,
5392                            orderByComparator);
5393            }
5394    
5395            /**
5396            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5397            *
5398            * @param groupId the group ID
5399            * @param folderId the folder ID
5400            * @param status the status
5401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5402            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5403            */
5404            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First(
5405                    long groupId, long folderId, int status,
5406                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5407                    return getPersistence()
5408                                       .fetchByG_F_ST_First(groupId, folderId, status,
5409                            orderByComparator);
5410            }
5411    
5412            /**
5413            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5414            *
5415            * @param groupId the group ID
5416            * @param folderId the folder ID
5417            * @param status the status
5418            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5419            * @return the last matching journal article
5420            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5421            */
5422            public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last(
5423                    long groupId, long folderId, int status,
5424                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5425                    throws com.liferay.portlet.journal.NoSuchArticleException {
5426                    return getPersistence()
5427                                       .findByG_F_ST_Last(groupId, folderId, status,
5428                            orderByComparator);
5429            }
5430    
5431            /**
5432            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5433            *
5434            * @param groupId the group ID
5435            * @param folderId the folder ID
5436            * @param status the status
5437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5438            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5439            */
5440            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last(
5441                    long groupId, long folderId, int status,
5442                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5443                    return getPersistence()
5444                                       .fetchByG_F_ST_Last(groupId, folderId, status,
5445                            orderByComparator);
5446            }
5447    
5448            /**
5449            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5450            *
5451            * @param id the primary key of the current journal article
5452            * @param groupId the group ID
5453            * @param folderId the folder ID
5454            * @param status the status
5455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5456            * @return the previous, current, and next journal article
5457            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5458            */
5459            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext(
5460                    long id, long groupId, long folderId, int status,
5461                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5462                    throws com.liferay.portlet.journal.NoSuchArticleException {
5463                    return getPersistence()
5464                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
5465                            orderByComparator);
5466            }
5467    
5468            /**
5469            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5470            *
5471            * @param groupId the group ID
5472            * @param folderId the folder ID
5473            * @param status the status
5474            * @return the matching journal articles that the user has permission to view
5475            */
5476            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5477                    long groupId, long folderId, int status) {
5478                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
5479            }
5480    
5481            /**
5482            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5483            *
5484            * <p>
5485            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5486            * </p>
5487            *
5488            * @param groupId the group ID
5489            * @param folderId the folder ID
5490            * @param status the status
5491            * @param start the lower bound of the range of journal articles
5492            * @param end the upper bound of the range of journal articles (not inclusive)
5493            * @return the range of matching journal articles that the user has permission to view
5494            */
5495            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5496                    long groupId, long folderId, int status, int start, int end) {
5497                    return getPersistence()
5498                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
5499            }
5500    
5501            /**
5502            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5503            *
5504            * <p>
5505            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5506            * </p>
5507            *
5508            * @param groupId the group ID
5509            * @param folderId the folder ID
5510            * @param status the status
5511            * @param start the lower bound of the range of journal articles
5512            * @param end the upper bound of the range of journal articles (not inclusive)
5513            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5514            * @return the ordered range of matching journal articles that the user has permission to view
5515            */
5516            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5517                    long groupId, long folderId, int status, int start, int end,
5518                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5519                    return getPersistence()
5520                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
5521                            orderByComparator);
5522            }
5523    
5524            /**
5525            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5526            *
5527            * @param id the primary key of the current journal article
5528            * @param groupId the group ID
5529            * @param folderId the folder ID
5530            * @param status the status
5531            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5532            * @return the previous, current, and next journal article
5533            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5534            */
5535            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext(
5536                    long id, long groupId, long folderId, int status,
5537                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5538                    throws com.liferay.portlet.journal.NoSuchArticleException {
5539                    return getPersistence()
5540                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
5541                            status, orderByComparator);
5542            }
5543    
5544            /**
5545            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5546            *
5547            * @param groupId the group ID
5548            * @param folderId the folder ID
5549            * @param statuses the statuses
5550            * @return the matching journal articles that the user has permission to view
5551            */
5552            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5553                    long groupId, long folderId, int[] statuses) {
5554                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
5555            }
5556    
5557            /**
5558            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5559            *
5560            * <p>
5561            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5562            * </p>
5563            *
5564            * @param groupId the group ID
5565            * @param folderId the folder ID
5566            * @param statuses the statuses
5567            * @param start the lower bound of the range of journal articles
5568            * @param end the upper bound of the range of journal articles (not inclusive)
5569            * @return the range of matching journal articles that the user has permission to view
5570            */
5571            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5572                    long groupId, long folderId, int[] statuses, int start, int end) {
5573                    return getPersistence()
5574                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
5575            }
5576    
5577            /**
5578            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5579            *
5580            * <p>
5581            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5582            * </p>
5583            *
5584            * @param groupId the group ID
5585            * @param folderId the folder ID
5586            * @param statuses the statuses
5587            * @param start the lower bound of the range of journal articles
5588            * @param end the upper bound of the range of journal articles (not inclusive)
5589            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5590            * @return the ordered range of matching journal articles that the user has permission to view
5591            */
5592            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST(
5593                    long groupId, long folderId, int[] statuses, int start, int end,
5594                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5595                    return getPersistence()
5596                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
5597                            orderByComparator);
5598            }
5599    
5600            /**
5601            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5602            *
5603            * <p>
5604            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5605            * </p>
5606            *
5607            * @param groupId the group ID
5608            * @param folderId the folder ID
5609            * @param statuses the statuses
5610            * @return the matching journal articles
5611            */
5612            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5613                    long groupId, long folderId, int[] statuses) {
5614                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
5615            }
5616    
5617            /**
5618            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5619            *
5620            * <p>
5621            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5622            * </p>
5623            *
5624            * @param groupId the group ID
5625            * @param folderId the folder ID
5626            * @param statuses the statuses
5627            * @param start the lower bound of the range of journal articles
5628            * @param end the upper bound of the range of journal articles (not inclusive)
5629            * @return the range of matching journal articles
5630            */
5631            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5632                    long groupId, long folderId, int[] statuses, int start, int end) {
5633                    return getPersistence()
5634                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
5635            }
5636    
5637            /**
5638            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5639            *
5640            * <p>
5641            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5642            * </p>
5643            *
5644            * @param groupId the group ID
5645            * @param folderId the folder ID
5646            * @param statuses the statuses
5647            * @param start the lower bound of the range of journal articles
5648            * @param end the upper bound of the range of journal articles (not inclusive)
5649            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5650            * @return the ordered range of matching journal articles
5651            */
5652            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST(
5653                    long groupId, long folderId, int[] statuses, int start, int end,
5654                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5655                    return getPersistence()
5656                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
5657                            orderByComparator);
5658            }
5659    
5660            /**
5661            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
5662            *
5663            * @param groupId the group ID
5664            * @param folderId the folder ID
5665            * @param status the status
5666            */
5667            public static void removeByG_F_ST(long groupId, long folderId, int status) {
5668                    getPersistence().removeByG_F_ST(groupId, folderId, status);
5669            }
5670    
5671            /**
5672            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5673            *
5674            * @param groupId the group ID
5675            * @param folderId the folder ID
5676            * @param status the status
5677            * @return the number of matching journal articles
5678            */
5679            public static int countByG_F_ST(long groupId, long folderId, int status) {
5680                    return getPersistence().countByG_F_ST(groupId, folderId, status);
5681            }
5682    
5683            /**
5684            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5685            *
5686            * @param groupId the group ID
5687            * @param folderId the folder ID
5688            * @param statuses the statuses
5689            * @return the number of matching journal articles
5690            */
5691            public static int countByG_F_ST(long groupId, long folderId, int[] statuses) {
5692                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
5693            }
5694    
5695            /**
5696            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5697            *
5698            * @param groupId the group ID
5699            * @param folderId the folder ID
5700            * @param status the status
5701            * @return the number of matching journal articles that the user has permission to view
5702            */
5703            public static int filterCountByG_F_ST(long groupId, long folderId,
5704                    int status) {
5705                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
5706            }
5707    
5708            /**
5709            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5710            *
5711            * @param groupId the group ID
5712            * @param folderId the folder ID
5713            * @param statuses the statuses
5714            * @return the number of matching journal articles that the user has permission to view
5715            */
5716            public static int filterCountByG_F_ST(long groupId, long folderId,
5717                    int[] statuses) {
5718                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
5719            }
5720    
5721            /**
5722            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5723            *
5724            * @param groupId the group ID
5725            * @param classNameId the class name ID
5726            * @param classPK the class p k
5727            * @return the matching journal articles
5728            */
5729            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5730                    long groupId, long classNameId, long classPK) {
5731                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5732            }
5733    
5734            /**
5735            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5736            *
5737            * <p>
5738            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5739            * </p>
5740            *
5741            * @param groupId the group ID
5742            * @param classNameId the class name ID
5743            * @param classPK the class p k
5744            * @param start the lower bound of the range of journal articles
5745            * @param end the upper bound of the range of journal articles (not inclusive)
5746            * @return the range of matching journal articles
5747            */
5748            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5749                    long groupId, long classNameId, long classPK, int start, int end) {
5750                    return getPersistence()
5751                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5752            }
5753    
5754            /**
5755            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5756            *
5757            * <p>
5758            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5759            * </p>
5760            *
5761            * @param groupId the group ID
5762            * @param classNameId the class name ID
5763            * @param classPK the class p k
5764            * @param start the lower bound of the range of journal articles
5765            * @param end the upper bound of the range of journal articles (not inclusive)
5766            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5767            * @return the ordered range of matching journal articles
5768            */
5769            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
5770                    long groupId, long classNameId, long classPK, int start, int end,
5771                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5772                    return getPersistence()
5773                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
5774                            orderByComparator);
5775            }
5776    
5777            /**
5778            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5779            *
5780            * @param groupId the group ID
5781            * @param classNameId the class name ID
5782            * @param classPK the class p k
5783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5784            * @return the first matching journal article
5785            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5786            */
5787            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
5788                    long groupId, long classNameId, long classPK,
5789                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5790                    throws com.liferay.portlet.journal.NoSuchArticleException {
5791                    return getPersistence()
5792                                       .findByG_C_C_First(groupId, classNameId, classPK,
5793                            orderByComparator);
5794            }
5795    
5796            /**
5797            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5798            *
5799            * @param groupId the group ID
5800            * @param classNameId the class name ID
5801            * @param classPK the class p k
5802            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5803            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5804            */
5805            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First(
5806                    long groupId, long classNameId, long classPK,
5807                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5808                    return getPersistence()
5809                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5810                            orderByComparator);
5811            }
5812    
5813            /**
5814            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5815            *
5816            * @param groupId the group ID
5817            * @param classNameId the class name ID
5818            * @param classPK the class p k
5819            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5820            * @return the last matching journal article
5821            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5822            */
5823            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
5824                    long groupId, long classNameId, long classPK,
5825                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5826                    throws com.liferay.portlet.journal.NoSuchArticleException {
5827                    return getPersistence()
5828                                       .findByG_C_C_Last(groupId, classNameId, classPK,
5829                            orderByComparator);
5830            }
5831    
5832            /**
5833            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5834            *
5835            * @param groupId the group ID
5836            * @param classNameId the class name ID
5837            * @param classPK the class p k
5838            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5839            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5840            */
5841            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last(
5842                    long groupId, long classNameId, long classPK,
5843                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5844                    return getPersistence()
5845                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
5846                            orderByComparator);
5847            }
5848    
5849            /**
5850            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5851            *
5852            * @param id the primary key of the current journal article
5853            * @param groupId the group ID
5854            * @param classNameId the class name ID
5855            * @param classPK the class p k
5856            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5857            * @return the previous, current, and next journal article
5858            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5859            */
5860            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
5861                    long id, long groupId, long classNameId, long classPK,
5862                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5863                    throws com.liferay.portlet.journal.NoSuchArticleException {
5864                    return getPersistence()
5865                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5866                            orderByComparator);
5867            }
5868    
5869            /**
5870            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5871            *
5872            * @param groupId the group ID
5873            * @param classNameId the class name ID
5874            * @param classPK the class p k
5875            * @return the matching journal articles that the user has permission to view
5876            */
5877            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5878                    long groupId, long classNameId, long classPK) {
5879                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5880            }
5881    
5882            /**
5883            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5884            *
5885            * <p>
5886            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5887            * </p>
5888            *
5889            * @param groupId the group ID
5890            * @param classNameId the class name ID
5891            * @param classPK the class p k
5892            * @param start the lower bound of the range of journal articles
5893            * @param end the upper bound of the range of journal articles (not inclusive)
5894            * @return the range of matching journal articles that the user has permission to view
5895            */
5896            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5897                    long groupId, long classNameId, long classPK, int start, int end) {
5898                    return getPersistence()
5899                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
5900            }
5901    
5902            /**
5903            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5904            *
5905            * <p>
5906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
5907            * </p>
5908            *
5909            * @param groupId the group ID
5910            * @param classNameId the class name ID
5911            * @param classPK the class p k
5912            * @param start the lower bound of the range of journal articles
5913            * @param end the upper bound of the range of journal articles (not inclusive)
5914            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5915            * @return the ordered range of matching journal articles that the user has permission to view
5916            */
5917            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
5918                    long groupId, long classNameId, long classPK, int start, int end,
5919                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
5920                    return getPersistence()
5921                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
5922                            end, orderByComparator);
5923            }
5924    
5925            /**
5926            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5927            *
5928            * @param id the primary key of the current journal article
5929            * @param groupId the group ID
5930            * @param classNameId the class name ID
5931            * @param classPK the class p k
5932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5933            * @return the previous, current, and next journal article
5934            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
5935            */
5936            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
5937                    long id, long groupId, long classNameId, long classPK,
5938                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
5939                    throws com.liferay.portlet.journal.NoSuchArticleException {
5940                    return getPersistence()
5941                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
5942                            classPK, orderByComparator);
5943            }
5944    
5945            /**
5946            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5947            *
5948            * @param groupId the group ID
5949            * @param classNameId the class name ID
5950            * @param classPK the class p k
5951            */
5952            public static void removeByG_C_C(long groupId, long classNameId,
5953                    long classPK) {
5954                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5955            }
5956    
5957            /**
5958            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5959            *
5960            * @param groupId the group ID
5961            * @param classNameId the class name ID
5962            * @param classPK the class p k
5963            * @return the number of matching journal articles
5964            */
5965            public static int countByG_C_C(long groupId, long classNameId, long classPK) {
5966                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5967            }
5968    
5969            /**
5970            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5971            *
5972            * @param groupId the group ID
5973            * @param classNameId the class name ID
5974            * @param classPK the class p k
5975            * @return the number of matching journal articles that the user has permission to view
5976            */
5977            public static int filterCountByG_C_C(long groupId, long classNameId,
5978                    long classPK) {
5979                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5980            }
5981    
5982            /**
5983            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
5984            *
5985            * @param groupId the group ID
5986            * @param classNameId the class name ID
5987            * @param structureId the structure ID
5988            * @return the matching journal article
5989            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
5990            */
5991            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
5992                    long groupId, long classNameId, java.lang.String structureId)
5993                    throws com.liferay.portlet.journal.NoSuchArticleException {
5994                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
5995            }
5996    
5997            /**
5998            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
5999            *
6000            * @param groupId the group ID
6001            * @param classNameId the class name ID
6002            * @param structureId the structure ID
6003            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6004            */
6005            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6006                    long groupId, long classNameId, java.lang.String structureId) {
6007                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
6008            }
6009    
6010            /**
6011            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
6012            *
6013            * @param groupId the group ID
6014            * @param classNameId the class name ID
6015            * @param structureId the structure ID
6016            * @param retrieveFromCache whether to use the finder cache
6017            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6018            */
6019            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
6020                    long groupId, long classNameId, java.lang.String structureId,
6021                    boolean retrieveFromCache) {
6022                    return getPersistence()
6023                                       .fetchByG_C_S(groupId, classNameId, structureId,
6024                            retrieveFromCache);
6025            }
6026    
6027            /**
6028            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
6029            *
6030            * @param groupId the group ID
6031            * @param classNameId the class name ID
6032            * @param structureId the structure ID
6033            * @return the journal article that was removed
6034            */
6035            public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S(
6036                    long groupId, long classNameId, java.lang.String structureId)
6037                    throws com.liferay.portlet.journal.NoSuchArticleException {
6038                    return getPersistence().removeByG_C_S(groupId, classNameId, structureId);
6039            }
6040    
6041            /**
6042            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
6043            *
6044            * @param groupId the group ID
6045            * @param classNameId the class name ID
6046            * @param structureId the structure ID
6047            * @return the number of matching journal articles
6048            */
6049            public static int countByG_C_S(long groupId, long classNameId,
6050                    java.lang.String structureId) {
6051                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
6052            }
6053    
6054            /**
6055            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6056            *
6057            * @param groupId the group ID
6058            * @param classNameId the class name ID
6059            * @param templateId the template ID
6060            * @return the matching journal articles
6061            */
6062            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6063                    long groupId, long classNameId, java.lang.String templateId) {
6064                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
6065            }
6066    
6067            /**
6068            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6069            *
6070            * <p>
6071            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6072            * </p>
6073            *
6074            * @param groupId the group ID
6075            * @param classNameId the class name ID
6076            * @param templateId the template ID
6077            * @param start the lower bound of the range of journal articles
6078            * @param end the upper bound of the range of journal articles (not inclusive)
6079            * @return the range of matching journal articles
6080            */
6081            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6082                    long groupId, long classNameId, java.lang.String templateId, int start,
6083                    int end) {
6084                    return getPersistence()
6085                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
6086            }
6087    
6088            /**
6089            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6090            *
6091            * <p>
6092            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6093            * </p>
6094            *
6095            * @param groupId the group ID
6096            * @param classNameId the class name ID
6097            * @param templateId the template ID
6098            * @param start the lower bound of the range of journal articles
6099            * @param end the upper bound of the range of journal articles (not inclusive)
6100            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6101            * @return the ordered range of matching journal articles
6102            */
6103            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
6104                    long groupId, long classNameId, java.lang.String templateId, int start,
6105                    int end,
6106                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6107                    return getPersistence()
6108                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
6109                            orderByComparator);
6110            }
6111    
6112            /**
6113            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6114            *
6115            * @param groupId the group ID
6116            * @param classNameId the class name ID
6117            * @param templateId the template ID
6118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6119            * @return the first matching journal article
6120            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6121            */
6122            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
6123                    long groupId, long classNameId, java.lang.String templateId,
6124                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6125                    throws com.liferay.portlet.journal.NoSuchArticleException {
6126                    return getPersistence()
6127                                       .findByG_C_T_First(groupId, classNameId, templateId,
6128                            orderByComparator);
6129            }
6130    
6131            /**
6132            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6133            *
6134            * @param groupId the group ID
6135            * @param classNameId the class name ID
6136            * @param templateId the template ID
6137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6138            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6139            */
6140            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First(
6141                    long groupId, long classNameId, java.lang.String templateId,
6142                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6143                    return getPersistence()
6144                                       .fetchByG_C_T_First(groupId, classNameId, templateId,
6145                            orderByComparator);
6146            }
6147    
6148            /**
6149            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6150            *
6151            * @param groupId the group ID
6152            * @param classNameId the class name ID
6153            * @param templateId the template ID
6154            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6155            * @return the last matching journal article
6156            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6157            */
6158            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
6159                    long groupId, long classNameId, java.lang.String templateId,
6160                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6161                    throws com.liferay.portlet.journal.NoSuchArticleException {
6162                    return getPersistence()
6163                                       .findByG_C_T_Last(groupId, classNameId, templateId,
6164                            orderByComparator);
6165            }
6166    
6167            /**
6168            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6169            *
6170            * @param groupId the group ID
6171            * @param classNameId the class name ID
6172            * @param templateId the template ID
6173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6174            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6175            */
6176            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last(
6177                    long groupId, long classNameId, java.lang.String templateId,
6178                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6179                    return getPersistence()
6180                                       .fetchByG_C_T_Last(groupId, classNameId, templateId,
6181                            orderByComparator);
6182            }
6183    
6184            /**
6185            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6186            *
6187            * @param id the primary key of the current journal article
6188            * @param groupId the group ID
6189            * @param classNameId the class name ID
6190            * @param templateId the template ID
6191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6192            * @return the previous, current, and next journal article
6193            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6194            */
6195            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
6196                    long id, long groupId, long classNameId, java.lang.String templateId,
6197                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6198                    throws com.liferay.portlet.journal.NoSuchArticleException {
6199                    return getPersistence()
6200                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
6201                            templateId, orderByComparator);
6202            }
6203    
6204            /**
6205            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6206            *
6207            * @param groupId the group ID
6208            * @param classNameId the class name ID
6209            * @param templateId the template ID
6210            * @return the matching journal articles that the user has permission to view
6211            */
6212            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6213                    long groupId, long classNameId, java.lang.String templateId) {
6214                    return getPersistence()
6215                                       .filterFindByG_C_T(groupId, classNameId, templateId);
6216            }
6217    
6218            /**
6219            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6220            *
6221            * <p>
6222            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6223            * </p>
6224            *
6225            * @param groupId the group ID
6226            * @param classNameId the class name ID
6227            * @param templateId the template ID
6228            * @param start the lower bound of the range of journal articles
6229            * @param end the upper bound of the range of journal articles (not inclusive)
6230            * @return the range of matching journal articles that the user has permission to view
6231            */
6232            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6233                    long groupId, long classNameId, java.lang.String templateId, int start,
6234                    int end) {
6235                    return getPersistence()
6236                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6237                            end);
6238            }
6239    
6240            /**
6241            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6242            *
6243            * <p>
6244            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6245            * </p>
6246            *
6247            * @param groupId the group ID
6248            * @param classNameId the class name ID
6249            * @param templateId the template ID
6250            * @param start the lower bound of the range of journal articles
6251            * @param end the upper bound of the range of journal articles (not inclusive)
6252            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6253            * @return the ordered range of matching journal articles that the user has permission to view
6254            */
6255            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
6256                    long groupId, long classNameId, java.lang.String templateId, int start,
6257                    int end,
6258                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6259                    return getPersistence()
6260                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
6261                            end, orderByComparator);
6262            }
6263    
6264            /**
6265            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6266            *
6267            * @param id the primary key of the current journal article
6268            * @param groupId the group ID
6269            * @param classNameId the class name ID
6270            * @param templateId the template ID
6271            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6272            * @return the previous, current, and next journal article
6273            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6274            */
6275            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
6276                    long id, long groupId, long classNameId, java.lang.String templateId,
6277                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6278                    throws com.liferay.portlet.journal.NoSuchArticleException {
6279                    return getPersistence()
6280                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
6281                            templateId, orderByComparator);
6282            }
6283    
6284            /**
6285            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
6286            *
6287            * @param groupId the group ID
6288            * @param classNameId the class name ID
6289            * @param templateId the template ID
6290            */
6291            public static void removeByG_C_T(long groupId, long classNameId,
6292                    java.lang.String templateId) {
6293                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
6294            }
6295    
6296            /**
6297            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6298            *
6299            * @param groupId the group ID
6300            * @param classNameId the class name ID
6301            * @param templateId the template ID
6302            * @return the number of matching journal articles
6303            */
6304            public static int countByG_C_T(long groupId, long classNameId,
6305                    java.lang.String templateId) {
6306                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
6307            }
6308    
6309            /**
6310            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
6311            *
6312            * @param groupId the group ID
6313            * @param classNameId the class name ID
6314            * @param templateId the template ID
6315            * @return the number of matching journal articles that the user has permission to view
6316            */
6317            public static int filterCountByG_C_T(long groupId, long classNameId,
6318                    java.lang.String templateId) {
6319                    return getPersistence()
6320                                       .filterCountByG_C_T(groupId, classNameId, templateId);
6321            }
6322    
6323            /**
6324            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6325            *
6326            * @param groupId the group ID
6327            * @param classNameId the class name ID
6328            * @param layoutUuid the layout uuid
6329            * @return the matching journal articles
6330            */
6331            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6332                    long groupId, long classNameId, java.lang.String layoutUuid) {
6333                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
6334            }
6335    
6336            /**
6337            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6338            *
6339            * <p>
6340            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6341            * </p>
6342            *
6343            * @param groupId the group ID
6344            * @param classNameId the class name ID
6345            * @param layoutUuid the layout uuid
6346            * @param start the lower bound of the range of journal articles
6347            * @param end the upper bound of the range of journal articles (not inclusive)
6348            * @return the range of matching journal articles
6349            */
6350            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6351                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6352                    int end) {
6353                    return getPersistence()
6354                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6355            }
6356    
6357            /**
6358            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6359            *
6360            * <p>
6361            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6362            * </p>
6363            *
6364            * @param groupId the group ID
6365            * @param classNameId the class name ID
6366            * @param layoutUuid the layout uuid
6367            * @param start the lower bound of the range of journal articles
6368            * @param end the upper bound of the range of journal articles (not inclusive)
6369            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6370            * @return the ordered range of matching journal articles
6371            */
6372            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
6373                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6374                    int end,
6375                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6376                    return getPersistence()
6377                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6378                            orderByComparator);
6379            }
6380    
6381            /**
6382            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6383            *
6384            * @param groupId the group ID
6385            * @param classNameId the class name ID
6386            * @param layoutUuid the layout uuid
6387            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6388            * @return the first matching journal article
6389            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6390            */
6391            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
6392                    long groupId, long classNameId, java.lang.String layoutUuid,
6393                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6394                    throws com.liferay.portlet.journal.NoSuchArticleException {
6395                    return getPersistence()
6396                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
6397                            orderByComparator);
6398            }
6399    
6400            /**
6401            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6402            *
6403            * @param groupId the group ID
6404            * @param classNameId the class name ID
6405            * @param layoutUuid the layout uuid
6406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6407            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6408            */
6409            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First(
6410                    long groupId, long classNameId, java.lang.String layoutUuid,
6411                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6412                    return getPersistence()
6413                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
6414                            orderByComparator);
6415            }
6416    
6417            /**
6418            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6419            *
6420            * @param groupId the group ID
6421            * @param classNameId the class name ID
6422            * @param layoutUuid the layout uuid
6423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6424            * @return the last matching journal article
6425            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6426            */
6427            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
6428                    long groupId, long classNameId, java.lang.String layoutUuid,
6429                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6430                    throws com.liferay.portlet.journal.NoSuchArticleException {
6431                    return getPersistence()
6432                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
6433                            orderByComparator);
6434            }
6435    
6436            /**
6437            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6438            *
6439            * @param groupId the group ID
6440            * @param classNameId the class name ID
6441            * @param layoutUuid the layout uuid
6442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6443            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6444            */
6445            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last(
6446                    long groupId, long classNameId, java.lang.String layoutUuid,
6447                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6448                    return getPersistence()
6449                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
6450                            orderByComparator);
6451            }
6452    
6453            /**
6454            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6455            *
6456            * @param id the primary key of the current journal article
6457            * @param groupId the group ID
6458            * @param classNameId the class name ID
6459            * @param layoutUuid the layout uuid
6460            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6461            * @return the previous, current, and next journal article
6462            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6463            */
6464            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
6465                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6466                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6467                    throws com.liferay.portlet.journal.NoSuchArticleException {
6468                    return getPersistence()
6469                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
6470                            layoutUuid, orderByComparator);
6471            }
6472    
6473            /**
6474            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6475            *
6476            * @param groupId the group ID
6477            * @param classNameId the class name ID
6478            * @param layoutUuid the layout uuid
6479            * @return the matching journal articles that the user has permission to view
6480            */
6481            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6482                    long groupId, long classNameId, java.lang.String layoutUuid) {
6483                    return getPersistence()
6484                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
6485            }
6486    
6487            /**
6488            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6489            *
6490            * <p>
6491            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6492            * </p>
6493            *
6494            * @param groupId the group ID
6495            * @param classNameId the class name ID
6496            * @param layoutUuid the layout uuid
6497            * @param start the lower bound of the range of journal articles
6498            * @param end the upper bound of the range of journal articles (not inclusive)
6499            * @return the range of matching journal articles that the user has permission to view
6500            */
6501            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6502                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6503                    int end) {
6504                    return getPersistence()
6505                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6506                            end);
6507            }
6508    
6509            /**
6510            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6511            *
6512            * <p>
6513            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6514            * </p>
6515            *
6516            * @param groupId the group ID
6517            * @param classNameId the class name ID
6518            * @param layoutUuid the layout uuid
6519            * @param start the lower bound of the range of journal articles
6520            * @param end the upper bound of the range of journal articles (not inclusive)
6521            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6522            * @return the ordered range of matching journal articles that the user has permission to view
6523            */
6524            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
6525                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
6526                    int end,
6527                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6528                    return getPersistence()
6529                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6530                            end, orderByComparator);
6531            }
6532    
6533            /**
6534            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6535            *
6536            * @param id the primary key of the current journal article
6537            * @param groupId the group ID
6538            * @param classNameId the class name ID
6539            * @param layoutUuid the layout uuid
6540            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6541            * @return the previous, current, and next journal article
6542            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6543            */
6544            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
6545                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
6546                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6547                    throws com.liferay.portlet.journal.NoSuchArticleException {
6548                    return getPersistence()
6549                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6550                            layoutUuid, orderByComparator);
6551            }
6552    
6553            /**
6554            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6555            *
6556            * @param groupId the group ID
6557            * @param classNameId the class name ID
6558            * @param layoutUuid the layout uuid
6559            */
6560            public static void removeByG_C_L(long groupId, long classNameId,
6561                    java.lang.String layoutUuid) {
6562                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6563            }
6564    
6565            /**
6566            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6567            *
6568            * @param groupId the group ID
6569            * @param classNameId the class name ID
6570            * @param layoutUuid the layout uuid
6571            * @return the number of matching journal articles
6572            */
6573            public static int countByG_C_L(long groupId, long classNameId,
6574                    java.lang.String layoutUuid) {
6575                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6576            }
6577    
6578            /**
6579            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6580            *
6581            * @param groupId the group ID
6582            * @param classNameId the class name ID
6583            * @param layoutUuid the layout uuid
6584            * @return the number of matching journal articles that the user has permission to view
6585            */
6586            public static int filterCountByG_C_L(long groupId, long classNameId,
6587                    java.lang.String layoutUuid) {
6588                    return getPersistence()
6589                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
6590            }
6591    
6592            /**
6593            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
6594            *
6595            * @param groupId the group ID
6596            * @param articleId the article ID
6597            * @param version the version
6598            * @return the matching journal article
6599            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6600            */
6601            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
6602                    long groupId, java.lang.String articleId, double version)
6603                    throws com.liferay.portlet.journal.NoSuchArticleException {
6604                    return getPersistence().findByG_A_V(groupId, articleId, version);
6605            }
6606    
6607            /**
6608            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
6609            *
6610            * @param groupId the group ID
6611            * @param articleId the article ID
6612            * @param version the version
6613            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6614            */
6615            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6616                    long groupId, java.lang.String articleId, double version) {
6617                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
6618            }
6619    
6620            /**
6621            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
6622            *
6623            * @param groupId the group ID
6624            * @param articleId the article ID
6625            * @param version the version
6626            * @param retrieveFromCache whether to use the finder cache
6627            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6628            */
6629            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
6630                    long groupId, java.lang.String articleId, double version,
6631                    boolean retrieveFromCache) {
6632                    return getPersistence()
6633                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
6634            }
6635    
6636            /**
6637            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
6638            *
6639            * @param groupId the group ID
6640            * @param articleId the article ID
6641            * @param version the version
6642            * @return the journal article that was removed
6643            */
6644            public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V(
6645                    long groupId, java.lang.String articleId, double version)
6646                    throws com.liferay.portlet.journal.NoSuchArticleException {
6647                    return getPersistence().removeByG_A_V(groupId, articleId, version);
6648            }
6649    
6650            /**
6651            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
6652            *
6653            * @param groupId the group ID
6654            * @param articleId the article ID
6655            * @param version the version
6656            * @return the number of matching journal articles
6657            */
6658            public static int countByG_A_V(long groupId, java.lang.String articleId,
6659                    double version) {
6660                    return getPersistence().countByG_A_V(groupId, articleId, version);
6661            }
6662    
6663            /**
6664            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6665            *
6666            * @param groupId the group ID
6667            * @param articleId the article ID
6668            * @param status the status
6669            * @return the matching journal articles
6670            */
6671            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6672                    long groupId, java.lang.String articleId, int status) {
6673                    return getPersistence().findByG_A_ST(groupId, articleId, status);
6674            }
6675    
6676            /**
6677            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6678            *
6679            * <p>
6680            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6681            * </p>
6682            *
6683            * @param groupId the group ID
6684            * @param articleId the article ID
6685            * @param status the status
6686            * @param start the lower bound of the range of journal articles
6687            * @param end the upper bound of the range of journal articles (not inclusive)
6688            * @return the range of matching journal articles
6689            */
6690            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6691                    long groupId, java.lang.String articleId, int status, int start, int end) {
6692                    return getPersistence()
6693                                       .findByG_A_ST(groupId, articleId, status, start, end);
6694            }
6695    
6696            /**
6697            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6698            *
6699            * <p>
6700            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6701            * </p>
6702            *
6703            * @param groupId the group ID
6704            * @param articleId the article ID
6705            * @param status the status
6706            * @param start the lower bound of the range of journal articles
6707            * @param end the upper bound of the range of journal articles (not inclusive)
6708            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6709            * @return the ordered range of matching journal articles
6710            */
6711            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6712                    long groupId, java.lang.String articleId, int status, int start,
6713                    int end,
6714                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6715                    return getPersistence()
6716                                       .findByG_A_ST(groupId, articleId, status, start, end,
6717                            orderByComparator);
6718            }
6719    
6720            /**
6721            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6722            *
6723            * @param groupId the group ID
6724            * @param articleId the article ID
6725            * @param status the status
6726            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6727            * @return the first matching journal article
6728            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6729            */
6730            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
6731                    long groupId, java.lang.String articleId, int status,
6732                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6733                    throws com.liferay.portlet.journal.NoSuchArticleException {
6734                    return getPersistence()
6735                                       .findByG_A_ST_First(groupId, articleId, status,
6736                            orderByComparator);
6737            }
6738    
6739            /**
6740            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6741            *
6742            * @param groupId the group ID
6743            * @param articleId the article ID
6744            * @param status the status
6745            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6746            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6747            */
6748            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First(
6749                    long groupId, java.lang.String articleId, int status,
6750                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6751                    return getPersistence()
6752                                       .fetchByG_A_ST_First(groupId, articleId, status,
6753                            orderByComparator);
6754            }
6755    
6756            /**
6757            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6758            *
6759            * @param groupId the group ID
6760            * @param articleId the article ID
6761            * @param status the status
6762            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6763            * @return the last matching journal article
6764            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
6765            */
6766            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
6767                    long groupId, java.lang.String articleId, int status,
6768                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6769                    throws com.liferay.portlet.journal.NoSuchArticleException {
6770                    return getPersistence()
6771                                       .findByG_A_ST_Last(groupId, articleId, status,
6772                            orderByComparator);
6773            }
6774    
6775            /**
6776            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6777            *
6778            * @param groupId the group ID
6779            * @param articleId the article ID
6780            * @param status the status
6781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6782            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6783            */
6784            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last(
6785                    long groupId, java.lang.String articleId, int status,
6786                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6787                    return getPersistence()
6788                                       .fetchByG_A_ST_Last(groupId, articleId, status,
6789                            orderByComparator);
6790            }
6791    
6792            /**
6793            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6794            *
6795            * @param id the primary key of the current journal article
6796            * @param groupId the group ID
6797            * @param articleId the article ID
6798            * @param status the status
6799            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6800            * @return the previous, current, and next journal article
6801            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6802            */
6803            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
6804                    long id, long groupId, java.lang.String articleId, int status,
6805                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6806                    throws com.liferay.portlet.journal.NoSuchArticleException {
6807                    return getPersistence()
6808                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
6809                            orderByComparator);
6810            }
6811    
6812            /**
6813            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6814            *
6815            * @param groupId the group ID
6816            * @param articleId the article ID
6817            * @param status the status
6818            * @return the matching journal articles that the user has permission to view
6819            */
6820            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6821                    long groupId, java.lang.String articleId, int status) {
6822                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
6823            }
6824    
6825            /**
6826            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6827            *
6828            * <p>
6829            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6830            * </p>
6831            *
6832            * @param groupId the group ID
6833            * @param articleId the article ID
6834            * @param status the status
6835            * @param start the lower bound of the range of journal articles
6836            * @param end the upper bound of the range of journal articles (not inclusive)
6837            * @return the range of matching journal articles that the user has permission to view
6838            */
6839            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6840                    long groupId, java.lang.String articleId, int status, int start, int end) {
6841                    return getPersistence()
6842                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
6843            }
6844    
6845            /**
6846            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6847            *
6848            * <p>
6849            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6850            * </p>
6851            *
6852            * @param groupId the group ID
6853            * @param articleId the article ID
6854            * @param status the status
6855            * @param start the lower bound of the range of journal articles
6856            * @param end the upper bound of the range of journal articles (not inclusive)
6857            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6858            * @return the ordered range of matching journal articles that the user has permission to view
6859            */
6860            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6861                    long groupId, java.lang.String articleId, int status, int start,
6862                    int end,
6863                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6864                    return getPersistence()
6865                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
6866                            orderByComparator);
6867            }
6868    
6869            /**
6870            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6871            *
6872            * @param id the primary key of the current journal article
6873            * @param groupId the group ID
6874            * @param articleId the article ID
6875            * @param status the status
6876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6877            * @return the previous, current, and next journal article
6878            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
6879            */
6880            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
6881                    long id, long groupId, java.lang.String articleId, int status,
6882                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
6883                    throws com.liferay.portlet.journal.NoSuchArticleException {
6884                    return getPersistence()
6885                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
6886                            status, orderByComparator);
6887            }
6888    
6889            /**
6890            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6891            *
6892            * @param groupId the group ID
6893            * @param articleId the article ID
6894            * @param statuses the statuses
6895            * @return the matching journal articles that the user has permission to view
6896            */
6897            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6898                    long groupId, java.lang.String articleId, int[] statuses) {
6899                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
6900            }
6901    
6902            /**
6903            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6904            *
6905            * <p>
6906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6907            * </p>
6908            *
6909            * @param groupId the group ID
6910            * @param articleId the article ID
6911            * @param statuses the statuses
6912            * @param start the lower bound of the range of journal articles
6913            * @param end the upper bound of the range of journal articles (not inclusive)
6914            * @return the range of matching journal articles that the user has permission to view
6915            */
6916            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6917                    long groupId, java.lang.String articleId, int[] statuses, int start,
6918                    int end) {
6919                    return getPersistence()
6920                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
6921            }
6922    
6923            /**
6924            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6925            *
6926            * <p>
6927            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6928            * </p>
6929            *
6930            * @param groupId the group ID
6931            * @param articleId the article ID
6932            * @param statuses the statuses
6933            * @param start the lower bound of the range of journal articles
6934            * @param end the upper bound of the range of journal articles (not inclusive)
6935            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6936            * @return the ordered range of matching journal articles that the user has permission to view
6937            */
6938            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
6939                    long groupId, java.lang.String articleId, int[] statuses, int start,
6940                    int end,
6941                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
6942                    return getPersistence()
6943                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
6944                            end, orderByComparator);
6945            }
6946    
6947            /**
6948            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6949            *
6950            * <p>
6951            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6952            * </p>
6953            *
6954            * @param groupId the group ID
6955            * @param articleId the article ID
6956            * @param statuses the statuses
6957            * @return the matching journal articles
6958            */
6959            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6960                    long groupId, java.lang.String articleId, int[] statuses) {
6961                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
6962            }
6963    
6964            /**
6965            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6966            *
6967            * <p>
6968            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6969            * </p>
6970            *
6971            * @param groupId the group ID
6972            * @param articleId the article ID
6973            * @param statuses the statuses
6974            * @param start the lower bound of the range of journal articles
6975            * @param end the upper bound of the range of journal articles (not inclusive)
6976            * @return the range of matching journal articles
6977            */
6978            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
6979                    long groupId, java.lang.String articleId, int[] statuses, int start,
6980                    int end) {
6981                    return getPersistence()
6982                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
6983            }
6984    
6985            /**
6986            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6987            *
6988            * <p>
6989            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
6990            * </p>
6991            *
6992            * @param groupId the group ID
6993            * @param articleId the article ID
6994            * @param statuses the statuses
6995            * @param start the lower bound of the range of journal articles
6996            * @param end the upper bound of the range of journal articles (not inclusive)
6997            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6998            * @return the ordered range of matching journal articles
6999            */
7000            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
7001                    long groupId, java.lang.String articleId, int[] statuses, int start,
7002                    int end,
7003                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7004                    return getPersistence()
7005                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
7006                            orderByComparator);
7007            }
7008    
7009            /**
7010            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
7011            *
7012            * @param groupId the group ID
7013            * @param articleId the article ID
7014            * @param status the status
7015            */
7016            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
7017                    int status) {
7018                    getPersistence().removeByG_A_ST(groupId, articleId, status);
7019            }
7020    
7021            /**
7022            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
7023            *
7024            * @param groupId the group ID
7025            * @param articleId the article ID
7026            * @param status the status
7027            * @return the number of matching journal articles
7028            */
7029            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7030                    int status) {
7031                    return getPersistence().countByG_A_ST(groupId, articleId, status);
7032            }
7033    
7034            /**
7035            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
7036            *
7037            * @param groupId the group ID
7038            * @param articleId the article ID
7039            * @param statuses the statuses
7040            * @return the number of matching journal articles
7041            */
7042            public static int countByG_A_ST(long groupId, java.lang.String articleId,
7043                    int[] statuses) {
7044                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
7045            }
7046    
7047            /**
7048            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
7049            *
7050            * @param groupId the group ID
7051            * @param articleId the article ID
7052            * @param status the status
7053            * @return the number of matching journal articles that the user has permission to view
7054            */
7055            public static int filterCountByG_A_ST(long groupId,
7056                    java.lang.String articleId, int status) {
7057                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
7058            }
7059    
7060            /**
7061            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
7062            *
7063            * @param groupId the group ID
7064            * @param articleId the article ID
7065            * @param statuses the statuses
7066            * @return the number of matching journal articles that the user has permission to view
7067            */
7068            public static int filterCountByG_A_ST(long groupId,
7069                    java.lang.String articleId, int[] statuses) {
7070                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
7071            }
7072    
7073            /**
7074            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7075            *
7076            * @param groupId the group ID
7077            * @param articleId the article ID
7078            * @param status the status
7079            * @return the matching journal articles
7080            */
7081            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
7082                    long groupId, java.lang.String articleId, int status) {
7083                    return getPersistence().findByG_A_NotST(groupId, articleId, status);
7084            }
7085    
7086            /**
7087            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7088            *
7089            * <p>
7090            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7091            * </p>
7092            *
7093            * @param groupId the group ID
7094            * @param articleId the article ID
7095            * @param status the status
7096            * @param start the lower bound of the range of journal articles
7097            * @param end the upper bound of the range of journal articles (not inclusive)
7098            * @return the range of matching journal articles
7099            */
7100            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
7101                    long groupId, java.lang.String articleId, int status, int start, int end) {
7102                    return getPersistence()
7103                                       .findByG_A_NotST(groupId, articleId, status, start, end);
7104            }
7105    
7106            /**
7107            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7108            *
7109            * <p>
7110            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7111            * </p>
7112            *
7113            * @param groupId the group ID
7114            * @param articleId the article ID
7115            * @param status the status
7116            * @param start the lower bound of the range of journal articles
7117            * @param end the upper bound of the range of journal articles (not inclusive)
7118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7119            * @return the ordered range of matching journal articles
7120            */
7121            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST(
7122                    long groupId, java.lang.String articleId, int status, int start,
7123                    int end,
7124                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7125                    return getPersistence()
7126                                       .findByG_A_NotST(groupId, articleId, status, start, end,
7127                            orderByComparator);
7128            }
7129    
7130            /**
7131            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7132            *
7133            * @param groupId the group ID
7134            * @param articleId the article ID
7135            * @param status the status
7136            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7137            * @return the first matching journal article
7138            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7139            */
7140            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_First(
7141                    long groupId, java.lang.String articleId, int status,
7142                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7143                    throws com.liferay.portlet.journal.NoSuchArticleException {
7144                    return getPersistence()
7145                                       .findByG_A_NotST_First(groupId, articleId, status,
7146                            orderByComparator);
7147            }
7148    
7149            /**
7150            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7151            *
7152            * @param groupId the group ID
7153            * @param articleId the article ID
7154            * @param status the status
7155            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7156            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7157            */
7158            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_First(
7159                    long groupId, java.lang.String articleId, int status,
7160                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7161                    return getPersistence()
7162                                       .fetchByG_A_NotST_First(groupId, articleId, status,
7163                            orderByComparator);
7164            }
7165    
7166            /**
7167            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7168            *
7169            * @param groupId the group ID
7170            * @param articleId the article ID
7171            * @param status the status
7172            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7173            * @return the last matching journal article
7174            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7175            */
7176            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_Last(
7177                    long groupId, java.lang.String articleId, int status,
7178                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7179                    throws com.liferay.portlet.journal.NoSuchArticleException {
7180                    return getPersistence()
7181                                       .findByG_A_NotST_Last(groupId, articleId, status,
7182                            orderByComparator);
7183            }
7184    
7185            /**
7186            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7187            *
7188            * @param groupId the group ID
7189            * @param articleId the article ID
7190            * @param status the status
7191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7192            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7193            */
7194            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_Last(
7195                    long groupId, java.lang.String articleId, int status,
7196                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7197                    return getPersistence()
7198                                       .fetchByG_A_NotST_Last(groupId, articleId, status,
7199                            orderByComparator);
7200            }
7201    
7202            /**
7203            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7204            *
7205            * @param id the primary key of the current journal article
7206            * @param groupId the group ID
7207            * @param articleId the article ID
7208            * @param status the status
7209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7210            * @return the previous, current, and next journal article
7211            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7212            */
7213            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_NotST_PrevAndNext(
7214                    long id, long groupId, java.lang.String articleId, int status,
7215                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7216                    throws com.liferay.portlet.journal.NoSuchArticleException {
7217                    return getPersistence()
7218                                       .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status,
7219                            orderByComparator);
7220            }
7221    
7222            /**
7223            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7224            *
7225            * @param groupId the group ID
7226            * @param articleId the article ID
7227            * @param status the status
7228            * @return the matching journal articles that the user has permission to view
7229            */
7230            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
7231                    long groupId, java.lang.String articleId, int status) {
7232                    return getPersistence().filterFindByG_A_NotST(groupId, articleId, status);
7233            }
7234    
7235            /**
7236            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7237            *
7238            * <p>
7239            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7240            * </p>
7241            *
7242            * @param groupId the group ID
7243            * @param articleId the article ID
7244            * @param status the status
7245            * @param start the lower bound of the range of journal articles
7246            * @param end the upper bound of the range of journal articles (not inclusive)
7247            * @return the range of matching journal articles that the user has permission to view
7248            */
7249            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
7250                    long groupId, java.lang.String articleId, int status, int start, int end) {
7251                    return getPersistence()
7252                                       .filterFindByG_A_NotST(groupId, articleId, status, start, end);
7253            }
7254    
7255            /**
7256            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7257            *
7258            * <p>
7259            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7260            * </p>
7261            *
7262            * @param groupId the group ID
7263            * @param articleId the article ID
7264            * @param status the status
7265            * @param start the lower bound of the range of journal articles
7266            * @param end the upper bound of the range of journal articles (not inclusive)
7267            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7268            * @return the ordered range of matching journal articles that the user has permission to view
7269            */
7270            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST(
7271                    long groupId, java.lang.String articleId, int status, int start,
7272                    int end,
7273                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7274                    return getPersistence()
7275                                       .filterFindByG_A_NotST(groupId, articleId, status, start,
7276                            end, orderByComparator);
7277            }
7278    
7279            /**
7280            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7281            *
7282            * @param id the primary key of the current journal article
7283            * @param groupId the group ID
7284            * @param articleId the article ID
7285            * @param status the status
7286            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7287            * @return the previous, current, and next journal article
7288            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7289            */
7290            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_NotST_PrevAndNext(
7291                    long id, long groupId, java.lang.String articleId, int status,
7292                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7293                    throws com.liferay.portlet.journal.NoSuchArticleException {
7294                    return getPersistence()
7295                                       .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId,
7296                            status, orderByComparator);
7297            }
7298    
7299            /**
7300            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63; from the database.
7301            *
7302            * @param groupId the group ID
7303            * @param articleId the article ID
7304            * @param status the status
7305            */
7306            public static void removeByG_A_NotST(long groupId,
7307                    java.lang.String articleId, int status) {
7308                    getPersistence().removeByG_A_NotST(groupId, articleId, status);
7309            }
7310    
7311            /**
7312            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7313            *
7314            * @param groupId the group ID
7315            * @param articleId the article ID
7316            * @param status the status
7317            * @return the number of matching journal articles
7318            */
7319            public static int countByG_A_NotST(long groupId,
7320                    java.lang.String articleId, int status) {
7321                    return getPersistence().countByG_A_NotST(groupId, articleId, status);
7322            }
7323    
7324            /**
7325            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7326            *
7327            * @param groupId the group ID
7328            * @param articleId the article ID
7329            * @param status the status
7330            * @return the number of matching journal articles that the user has permission to view
7331            */
7332            public static int filterCountByG_A_NotST(long groupId,
7333                    java.lang.String articleId, int status) {
7334                    return getPersistence()
7335                                       .filterCountByG_A_NotST(groupId, articleId, status);
7336            }
7337    
7338            /**
7339            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7340            *
7341            * @param groupId the group ID
7342            * @param urlTitle the url title
7343            * @param status the status
7344            * @return the matching journal articles
7345            */
7346            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7347                    long groupId, java.lang.String urlTitle, int status) {
7348                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
7349            }
7350    
7351            /**
7352            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7353            *
7354            * <p>
7355            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7356            * </p>
7357            *
7358            * @param groupId the group ID
7359            * @param urlTitle the url title
7360            * @param status the status
7361            * @param start the lower bound of the range of journal articles
7362            * @param end the upper bound of the range of journal articles (not inclusive)
7363            * @return the range of matching journal articles
7364            */
7365            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7366                    long groupId, java.lang.String urlTitle, int status, int start, int end) {
7367                    return getPersistence()
7368                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
7369            }
7370    
7371            /**
7372            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7373            *
7374            * <p>
7375            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7376            * </p>
7377            *
7378            * @param groupId the group ID
7379            * @param urlTitle the url title
7380            * @param status the status
7381            * @param start the lower bound of the range of journal articles
7382            * @param end the upper bound of the range of journal articles (not inclusive)
7383            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7384            * @return the ordered range of matching journal articles
7385            */
7386            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
7387                    long groupId, java.lang.String urlTitle, int status, int start,
7388                    int end,
7389                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7390                    return getPersistence()
7391                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
7392                            orderByComparator);
7393            }
7394    
7395            /**
7396            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7397            *
7398            * @param groupId the group ID
7399            * @param urlTitle the url title
7400            * @param status the status
7401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7402            * @return the first matching journal article
7403            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7404            */
7405            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
7406                    long groupId, java.lang.String urlTitle, int status,
7407                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7408                    throws com.liferay.portlet.journal.NoSuchArticleException {
7409                    return getPersistence()
7410                                       .findByG_UT_ST_First(groupId, urlTitle, status,
7411                            orderByComparator);
7412            }
7413    
7414            /**
7415            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7416            *
7417            * @param groupId the group ID
7418            * @param urlTitle the url title
7419            * @param status the status
7420            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7421            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7422            */
7423            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First(
7424                    long groupId, java.lang.String urlTitle, int status,
7425                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7426                    return getPersistence()
7427                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
7428                            orderByComparator);
7429            }
7430    
7431            /**
7432            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7433            *
7434            * @param groupId the group ID
7435            * @param urlTitle the url title
7436            * @param status the status
7437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7438            * @return the last matching journal article
7439            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7440            */
7441            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
7442                    long groupId, java.lang.String urlTitle, int status,
7443                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7444                    throws com.liferay.portlet.journal.NoSuchArticleException {
7445                    return getPersistence()
7446                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
7447                            orderByComparator);
7448            }
7449    
7450            /**
7451            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7452            *
7453            * @param groupId the group ID
7454            * @param urlTitle the url title
7455            * @param status the status
7456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7457            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7458            */
7459            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last(
7460                    long groupId, java.lang.String urlTitle, int status,
7461                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7462                    return getPersistence()
7463                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
7464                            orderByComparator);
7465            }
7466    
7467            /**
7468            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7469            *
7470            * @param id the primary key of the current journal article
7471            * @param groupId the group ID
7472            * @param urlTitle the url title
7473            * @param status the status
7474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7475            * @return the previous, current, and next journal article
7476            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7477            */
7478            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
7479                    long id, long groupId, java.lang.String urlTitle, int status,
7480                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7481                    throws com.liferay.portlet.journal.NoSuchArticleException {
7482                    return getPersistence()
7483                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
7484                            orderByComparator);
7485            }
7486    
7487            /**
7488            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7489            *
7490            * @param groupId the group ID
7491            * @param urlTitle the url title
7492            * @param status the status
7493            * @return the matching journal articles that the user has permission to view
7494            */
7495            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7496                    long groupId, java.lang.String urlTitle, int status) {
7497                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
7498            }
7499    
7500            /**
7501            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7502            *
7503            * <p>
7504            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7505            * </p>
7506            *
7507            * @param groupId the group ID
7508            * @param urlTitle the url title
7509            * @param status the status
7510            * @param start the lower bound of the range of journal articles
7511            * @param end the upper bound of the range of journal articles (not inclusive)
7512            * @return the range of matching journal articles that the user has permission to view
7513            */
7514            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7515                    long groupId, java.lang.String urlTitle, int status, int start, int end) {
7516                    return getPersistence()
7517                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7518            }
7519    
7520            /**
7521            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7522            *
7523            * <p>
7524            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7525            * </p>
7526            *
7527            * @param groupId the group ID
7528            * @param urlTitle the url title
7529            * @param status the status
7530            * @param start the lower bound of the range of journal articles
7531            * @param end the upper bound of the range of journal articles (not inclusive)
7532            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7533            * @return the ordered range of matching journal articles that the user has permission to view
7534            */
7535            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
7536                    long groupId, java.lang.String urlTitle, int status, int start,
7537                    int end,
7538                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7539                    return getPersistence()
7540                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7541                            orderByComparator);
7542            }
7543    
7544            /**
7545            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7546            *
7547            * @param id the primary key of the current journal article
7548            * @param groupId the group ID
7549            * @param urlTitle the url title
7550            * @param status the status
7551            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7552            * @return the previous, current, and next journal article
7553            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7554            */
7555            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
7556                    long id, long groupId, java.lang.String urlTitle, int status,
7557                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7558                    throws com.liferay.portlet.journal.NoSuchArticleException {
7559                    return getPersistence()
7560                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7561                            status, orderByComparator);
7562            }
7563    
7564            /**
7565            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7566            *
7567            * @param groupId the group ID
7568            * @param urlTitle the url title
7569            * @param status the status
7570            */
7571            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7572                    int status) {
7573                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7574            }
7575    
7576            /**
7577            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7578            *
7579            * @param groupId the group ID
7580            * @param urlTitle the url title
7581            * @param status the status
7582            * @return the number of matching journal articles
7583            */
7584            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7585                    int status) {
7586                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7587            }
7588    
7589            /**
7590            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7591            *
7592            * @param groupId the group ID
7593            * @param urlTitle the url title
7594            * @param status the status
7595            * @return the number of matching journal articles that the user has permission to view
7596            */
7597            public static int filterCountByG_UT_ST(long groupId,
7598                    java.lang.String urlTitle, int status) {
7599                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7600            }
7601    
7602            /**
7603            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7604            *
7605            * @param companyId the company ID
7606            * @param version the version
7607            * @param status the status
7608            * @return the matching journal articles
7609            */
7610            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7611                    long companyId, double version, int status) {
7612                    return getPersistence().findByC_V_ST(companyId, version, status);
7613            }
7614    
7615            /**
7616            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7617            *
7618            * <p>
7619            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7620            * </p>
7621            *
7622            * @param companyId the company ID
7623            * @param version the version
7624            * @param status the status
7625            * @param start the lower bound of the range of journal articles
7626            * @param end the upper bound of the range of journal articles (not inclusive)
7627            * @return the range of matching journal articles
7628            */
7629            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7630                    long companyId, double version, int status, int start, int end) {
7631                    return getPersistence()
7632                                       .findByC_V_ST(companyId, version, status, start, end);
7633            }
7634    
7635            /**
7636            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7637            *
7638            * <p>
7639            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7640            * </p>
7641            *
7642            * @param companyId the company ID
7643            * @param version the version
7644            * @param status the status
7645            * @param start the lower bound of the range of journal articles
7646            * @param end the upper bound of the range of journal articles (not inclusive)
7647            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7648            * @return the ordered range of matching journal articles
7649            */
7650            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
7651                    long companyId, double version, int status, int start, int end,
7652                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7653                    return getPersistence()
7654                                       .findByC_V_ST(companyId, version, status, start, end,
7655                            orderByComparator);
7656            }
7657    
7658            /**
7659            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7660            *
7661            * @param companyId the company ID
7662            * @param version the version
7663            * @param status the status
7664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7665            * @return the first matching journal article
7666            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7667            */
7668            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
7669                    long companyId, double version, int status,
7670                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7671                    throws com.liferay.portlet.journal.NoSuchArticleException {
7672                    return getPersistence()
7673                                       .findByC_V_ST_First(companyId, version, status,
7674                            orderByComparator);
7675            }
7676    
7677            /**
7678            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7679            *
7680            * @param companyId the company ID
7681            * @param version the version
7682            * @param status the status
7683            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7684            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7685            */
7686            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First(
7687                    long companyId, double version, int status,
7688                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7689                    return getPersistence()
7690                                       .fetchByC_V_ST_First(companyId, version, status,
7691                            orderByComparator);
7692            }
7693    
7694            /**
7695            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7696            *
7697            * @param companyId the company ID
7698            * @param version the version
7699            * @param status the status
7700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7701            * @return the last matching journal article
7702            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
7703            */
7704            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
7705                    long companyId, double version, int status,
7706                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7707                    throws com.liferay.portlet.journal.NoSuchArticleException {
7708                    return getPersistence()
7709                                       .findByC_V_ST_Last(companyId, version, status,
7710                            orderByComparator);
7711            }
7712    
7713            /**
7714            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7715            *
7716            * @param companyId the company ID
7717            * @param version the version
7718            * @param status the status
7719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7720            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7721            */
7722            public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last(
7723                    long companyId, double version, int status,
7724                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7725                    return getPersistence()
7726                                       .fetchByC_V_ST_Last(companyId, version, status,
7727                            orderByComparator);
7728            }
7729    
7730            /**
7731            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7732            *
7733            * @param id the primary key of the current journal article
7734            * @param companyId the company ID
7735            * @param version the version
7736            * @param status the status
7737            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7738            * @return the previous, current, and next journal article
7739            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7740            */
7741            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
7742                    long id, long companyId, double version, int status,
7743                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator)
7744                    throws com.liferay.portlet.journal.NoSuchArticleException {
7745                    return getPersistence()
7746                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7747                            orderByComparator);
7748            }
7749    
7750            /**
7751            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7752            *
7753            * @param companyId the company ID
7754            * @param version the version
7755            * @param status the status
7756            */
7757            public static void removeByC_V_ST(long companyId, double version, int status) {
7758                    getPersistence().removeByC_V_ST(companyId, version, status);
7759            }
7760    
7761            /**
7762            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7763            *
7764            * @param companyId the company ID
7765            * @param version the version
7766            * @param status the status
7767            * @return the number of matching journal articles
7768            */
7769            public static int countByC_V_ST(long companyId, double version, int status) {
7770                    return getPersistence().countByC_V_ST(companyId, version, status);
7771            }
7772    
7773            /**
7774            * Caches the journal article in the entity cache if it is enabled.
7775            *
7776            * @param journalArticle the journal article
7777            */
7778            public static void cacheResult(
7779                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7780                    getPersistence().cacheResult(journalArticle);
7781            }
7782    
7783            /**
7784            * Caches the journal articles in the entity cache if it is enabled.
7785            *
7786            * @param journalArticles the journal articles
7787            */
7788            public static void cacheResult(
7789                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
7790                    getPersistence().cacheResult(journalArticles);
7791            }
7792    
7793            /**
7794            * Creates a new journal article with the primary key. Does not add the journal article to the database.
7795            *
7796            * @param id the primary key for the new journal article
7797            * @return the new journal article
7798            */
7799            public static com.liferay.portlet.journal.model.JournalArticle create(
7800                    long id) {
7801                    return getPersistence().create(id);
7802            }
7803    
7804            /**
7805            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
7806            *
7807            * @param id the primary key of the journal article
7808            * @return the journal article that was removed
7809            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7810            */
7811            public static com.liferay.portlet.journal.model.JournalArticle remove(
7812                    long id) throws com.liferay.portlet.journal.NoSuchArticleException {
7813                    return getPersistence().remove(id);
7814            }
7815    
7816            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
7817                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
7818                    return getPersistence().updateImpl(journalArticle);
7819            }
7820    
7821            /**
7822            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
7823            *
7824            * @param id the primary key of the journal article
7825            * @return the journal article
7826            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
7827            */
7828            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
7829                    long id) throws com.liferay.portlet.journal.NoSuchArticleException {
7830                    return getPersistence().findByPrimaryKey(id);
7831            }
7832    
7833            /**
7834            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
7835            *
7836            * @param id the primary key of the journal article
7837            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
7838            */
7839            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
7840                    long id) {
7841                    return getPersistence().fetchByPrimaryKey(id);
7842            }
7843    
7844            public static java.util.Map<java.io.Serializable, com.liferay.portlet.journal.model.JournalArticle> fetchByPrimaryKeys(
7845                    java.util.Set<java.io.Serializable> primaryKeys) {
7846                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
7847            }
7848    
7849            /**
7850            * Returns all the journal articles.
7851            *
7852            * @return the journal articles
7853            */
7854            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() {
7855                    return getPersistence().findAll();
7856            }
7857    
7858            /**
7859            * Returns a range of all the journal articles.
7860            *
7861            * <p>
7862            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7863            * </p>
7864            *
7865            * @param start the lower bound of the range of journal articles
7866            * @param end the upper bound of the range of journal articles (not inclusive)
7867            * @return the range of journal articles
7868            */
7869            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7870                    int start, int end) {
7871                    return getPersistence().findAll(start, end);
7872            }
7873    
7874            /**
7875            * Returns an ordered range of all the journal articles.
7876            *
7877            * <p>
7878            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. 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.
7879            * </p>
7880            *
7881            * @param start the lower bound of the range of journal articles
7882            * @param end the upper bound of the range of journal articles (not inclusive)
7883            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7884            * @return the ordered range of journal articles
7885            */
7886            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
7887                    int start, int end,
7888                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalArticle> orderByComparator) {
7889                    return getPersistence().findAll(start, end, orderByComparator);
7890            }
7891    
7892            /**
7893            * Removes all the journal articles from the database.
7894            */
7895            public static void removeAll() {
7896                    getPersistence().removeAll();
7897            }
7898    
7899            /**
7900            * Returns the number of journal articles.
7901            *
7902            * @return the number of journal articles
7903            */
7904            public static int countAll() {
7905                    return getPersistence().countAll();
7906            }
7907    
7908            public static JournalArticlePersistence getPersistence() {
7909                    if (_persistence == null) {
7910                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
7911    
7912                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
7913                                    "_persistence");
7914                    }
7915    
7916                    return _persistence;
7917            }
7918    
7919            /**
7920             * @deprecated As of 6.2.0
7921             */
7922            @Deprecated
7923            public void setPersistence(JournalArticlePersistence persistence) {
7924            }
7925    
7926            private static JournalArticlePersistence _persistence;
7927    }