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 com.liferay.portlet.journal.service.persistence.impl.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 com.liferay.portlet.journal.service.persistence.impl.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 List<JournalArticle> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the journal articles where uuid = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of journal articles
131            * @param end the upper bound of the range of journal articles (not inclusive)
132            * @return the range of matching journal articles
133            */
134            public static List<JournalArticle> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the journal articles where uuid = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of journal articles
148            * @param end the upper bound of the range of journal articles (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching journal articles
151            */
152            public static List<JournalArticle> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first journal article in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching journal article
163            * @throws NoSuchArticleException if a matching journal article could not be found
164            */
165            public static JournalArticle findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<JournalArticle> orderByComparator)
167                    throws com.liferay.portlet.journal.NoSuchArticleException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first journal article in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
177            */
178            public static JournalArticle fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<JournalArticle> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last journal article in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching journal article
189            * @throws NoSuchArticleException if a matching journal article could not be found
190            */
191            public static JournalArticle findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<JournalArticle> orderByComparator)
193                    throws com.liferay.portlet.journal.NoSuchArticleException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last journal article in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
203            */
204            public static JournalArticle fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<JournalArticle> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
211            *
212            * @param id the primary key of the current journal article
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next journal article
216            * @throws NoSuchArticleException if a journal article with the primary key could not be found
217            */
218            public static JournalArticle[] findByUuid_PrevAndNext(long id,
219                    java.lang.String uuid,
220                    OrderByComparator<JournalArticle> orderByComparator)
221                    throws com.liferay.portlet.journal.NoSuchArticleException {
222                    return getPersistence()
223                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
224            }
225    
226            /**
227            * Removes all the journal articles where uuid = &#63; from the database.
228            *
229            * @param uuid the uuid
230            */
231            public static void removeByUuid(java.lang.String uuid) {
232                    getPersistence().removeByUuid(uuid);
233            }
234    
235            /**
236            * Returns the number of journal articles where uuid = &#63;.
237            *
238            * @param uuid the uuid
239            * @return the number of matching journal articles
240            */
241            public static int countByUuid(java.lang.String uuid) {
242                    return getPersistence().countByUuid(uuid);
243            }
244    
245            /**
246            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchArticleException} if it could not be found.
247            *
248            * @param uuid the uuid
249            * @param groupId the group ID
250            * @return the matching journal article
251            * @throws NoSuchArticleException if a matching journal article could not be found
252            */
253            public static JournalArticle findByUUID_G(java.lang.String uuid,
254                    long groupId) throws com.liferay.portlet.journal.NoSuchArticleException {
255                    return getPersistence().findByUUID_G(uuid, groupId);
256            }
257    
258            /**
259            * 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.
260            *
261            * @param uuid the uuid
262            * @param groupId the group ID
263            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
264            */
265            public static JournalArticle fetchByUUID_G(java.lang.String uuid,
266                    long groupId) {
267                    return getPersistence().fetchByUUID_G(uuid, groupId);
268            }
269    
270            /**
271            * 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.
272            *
273            * @param uuid the uuid
274            * @param groupId the group ID
275            * @param retrieveFromCache whether to use the finder cache
276            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
277            */
278            public static JournalArticle fetchByUUID_G(java.lang.String uuid,
279                    long groupId, boolean retrieveFromCache) {
280                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
281            }
282    
283            /**
284            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
285            *
286            * @param uuid the uuid
287            * @param groupId the group ID
288            * @return the journal article that was removed
289            */
290            public static JournalArticle removeByUUID_G(java.lang.String uuid,
291                    long groupId) throws com.liferay.portlet.journal.NoSuchArticleException {
292                    return getPersistence().removeByUUID_G(uuid, groupId);
293            }
294    
295            /**
296            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
297            *
298            * @param uuid the uuid
299            * @param groupId the group ID
300            * @return the number of matching journal articles
301            */
302            public static int countByUUID_G(java.lang.String uuid, long groupId) {
303                    return getPersistence().countByUUID_G(uuid, groupId);
304            }
305    
306            /**
307            * Returns all the journal articles where uuid = &#63; and companyId = &#63;.
308            *
309            * @param uuid the uuid
310            * @param companyId the company ID
311            * @return the matching journal articles
312            */
313            public static List<JournalArticle> findByUuid_C(java.lang.String uuid,
314                    long companyId) {
315                    return getPersistence().findByUuid_C(uuid, companyId);
316            }
317    
318            /**
319            * Returns a range of all the journal articles where uuid = &#63; and companyId = &#63;.
320            *
321            * <p>
322            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
323            * </p>
324            *
325            * @param uuid the uuid
326            * @param companyId the company ID
327            * @param start the lower bound of the range of journal articles
328            * @param end the upper bound of the range of journal articles (not inclusive)
329            * @return the range of matching journal articles
330            */
331            public static List<JournalArticle> findByUuid_C(java.lang.String uuid,
332                    long companyId, int start, int end) {
333                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
334            }
335    
336            /**
337            * Returns an ordered range of all the journal articles where uuid = &#63; and companyId = &#63;.
338            *
339            * <p>
340            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
341            * </p>
342            *
343            * @param uuid the uuid
344            * @param companyId the company ID
345            * @param start the lower bound of the range of journal articles
346            * @param end the upper bound of the range of journal articles (not inclusive)
347            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
348            * @return the ordered range of matching journal articles
349            */
350            public static List<JournalArticle> findByUuid_C(java.lang.String uuid,
351                    long companyId, int start, int end,
352                    OrderByComparator<JournalArticle> orderByComparator) {
353                    return getPersistence()
354                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
355            }
356    
357            /**
358            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
359            *
360            * @param uuid the uuid
361            * @param companyId the company ID
362            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
363            * @return the first matching journal article
364            * @throws NoSuchArticleException if a matching journal article could not be found
365            */
366            public static JournalArticle findByUuid_C_First(java.lang.String uuid,
367                    long companyId, OrderByComparator<JournalArticle> orderByComparator)
368                    throws com.liferay.portlet.journal.NoSuchArticleException {
369                    return getPersistence()
370                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
371            }
372    
373            /**
374            * Returns the first journal article in the ordered set where uuid = &#63; and companyId = &#63;.
375            *
376            * @param uuid the uuid
377            * @param companyId the company ID
378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
379            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
380            */
381            public static JournalArticle fetchByUuid_C_First(java.lang.String uuid,
382                    long companyId, OrderByComparator<JournalArticle> orderByComparator) {
383                    return getPersistence()
384                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
385            }
386    
387            /**
388            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
389            *
390            * @param uuid the uuid
391            * @param companyId the company ID
392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
393            * @return the last matching journal article
394            * @throws NoSuchArticleException if a matching journal article could not be found
395            */
396            public static JournalArticle findByUuid_C_Last(java.lang.String uuid,
397                    long companyId, OrderByComparator<JournalArticle> orderByComparator)
398                    throws com.liferay.portlet.journal.NoSuchArticleException {
399                    return getPersistence()
400                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
401            }
402    
403            /**
404            * Returns the last journal article in the ordered set where uuid = &#63; and companyId = &#63;.
405            *
406            * @param uuid the uuid
407            * @param companyId the company ID
408            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
409            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
410            */
411            public static JournalArticle fetchByUuid_C_Last(java.lang.String uuid,
412                    long companyId, OrderByComparator<JournalArticle> orderByComparator) {
413                    return getPersistence()
414                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
415            }
416    
417            /**
418            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63; and companyId = &#63;.
419            *
420            * @param id the primary key of the current journal article
421            * @param uuid the uuid
422            * @param companyId the company ID
423            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
424            * @return the previous, current, and next journal article
425            * @throws NoSuchArticleException if a journal article with the primary key could not be found
426            */
427            public static JournalArticle[] findByUuid_C_PrevAndNext(long id,
428                    java.lang.String uuid, long companyId,
429                    OrderByComparator<JournalArticle> orderByComparator)
430                    throws com.liferay.portlet.journal.NoSuchArticleException {
431                    return getPersistence()
432                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
433                            orderByComparator);
434            }
435    
436            /**
437            * Removes all the journal articles where uuid = &#63; and companyId = &#63; from the database.
438            *
439            * @param uuid the uuid
440            * @param companyId the company ID
441            */
442            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
443                    getPersistence().removeByUuid_C(uuid, companyId);
444            }
445    
446            /**
447            * Returns the number of journal articles where uuid = &#63; and companyId = &#63;.
448            *
449            * @param uuid the uuid
450            * @param companyId the company ID
451            * @return the number of matching journal articles
452            */
453            public static int countByUuid_C(java.lang.String uuid, long companyId) {
454                    return getPersistence().countByUuid_C(uuid, companyId);
455            }
456    
457            /**
458            * Returns all the journal articles where resourcePrimKey = &#63;.
459            *
460            * @param resourcePrimKey the resource prim key
461            * @return the matching journal articles
462            */
463            public static List<JournalArticle> findByResourcePrimKey(
464                    long resourcePrimKey) {
465                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
466            }
467    
468            /**
469            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
470            *
471            * <p>
472            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
473            * </p>
474            *
475            * @param resourcePrimKey the resource prim key
476            * @param start the lower bound of the range of journal articles
477            * @param end the upper bound of the range of journal articles (not inclusive)
478            * @return the range of matching journal articles
479            */
480            public static List<JournalArticle> findByResourcePrimKey(
481                    long resourcePrimKey, int start, int end) {
482                    return getPersistence()
483                                       .findByResourcePrimKey(resourcePrimKey, start, end);
484            }
485    
486            /**
487            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
488            *
489            * <p>
490            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
491            * </p>
492            *
493            * @param resourcePrimKey the resource prim key
494            * @param start the lower bound of the range of journal articles
495            * @param end the upper bound of the range of journal articles (not inclusive)
496            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
497            * @return the ordered range of matching journal articles
498            */
499            public static List<JournalArticle> findByResourcePrimKey(
500                    long resourcePrimKey, int start, int end,
501                    OrderByComparator<JournalArticle> orderByComparator) {
502                    return getPersistence()
503                                       .findByResourcePrimKey(resourcePrimKey, start, end,
504                            orderByComparator);
505            }
506    
507            /**
508            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
509            *
510            * @param resourcePrimKey the resource prim key
511            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
512            * @return the first matching journal article
513            * @throws NoSuchArticleException if a matching journal article could not be found
514            */
515            public static JournalArticle findByResourcePrimKey_First(
516                    long resourcePrimKey,
517                    OrderByComparator<JournalArticle> orderByComparator)
518                    throws com.liferay.portlet.journal.NoSuchArticleException {
519                    return getPersistence()
520                                       .findByResourcePrimKey_First(resourcePrimKey,
521                            orderByComparator);
522            }
523    
524            /**
525            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
526            *
527            * @param resourcePrimKey the resource prim key
528            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
529            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
530            */
531            public static JournalArticle fetchByResourcePrimKey_First(
532                    long resourcePrimKey,
533                    OrderByComparator<JournalArticle> orderByComparator) {
534                    return getPersistence()
535                                       .fetchByResourcePrimKey_First(resourcePrimKey,
536                            orderByComparator);
537            }
538    
539            /**
540            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
541            *
542            * @param resourcePrimKey the resource prim key
543            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
544            * @return the last matching journal article
545            * @throws NoSuchArticleException if a matching journal article could not be found
546            */
547            public static JournalArticle findByResourcePrimKey_Last(
548                    long resourcePrimKey,
549                    OrderByComparator<JournalArticle> orderByComparator)
550                    throws com.liferay.portlet.journal.NoSuchArticleException {
551                    return getPersistence()
552                                       .findByResourcePrimKey_Last(resourcePrimKey,
553                            orderByComparator);
554            }
555    
556            /**
557            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
558            *
559            * @param resourcePrimKey the resource prim key
560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
561            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
562            */
563            public static JournalArticle fetchByResourcePrimKey_Last(
564                    long resourcePrimKey,
565                    OrderByComparator<JournalArticle> orderByComparator) {
566                    return getPersistence()
567                                       .fetchByResourcePrimKey_Last(resourcePrimKey,
568                            orderByComparator);
569            }
570    
571            /**
572            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
573            *
574            * @param id the primary key of the current journal article
575            * @param resourcePrimKey the resource prim key
576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
577            * @return the previous, current, and next journal article
578            * @throws NoSuchArticleException if a journal article with the primary key could not be found
579            */
580            public static JournalArticle[] findByResourcePrimKey_PrevAndNext(long id,
581                    long resourcePrimKey,
582                    OrderByComparator<JournalArticle> orderByComparator)
583                    throws com.liferay.portlet.journal.NoSuchArticleException {
584                    return getPersistence()
585                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
586                            orderByComparator);
587            }
588    
589            /**
590            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
591            *
592            * @param resourcePrimKey the resource prim key
593            */
594            public static void removeByResourcePrimKey(long resourcePrimKey) {
595                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
596            }
597    
598            /**
599            * Returns the number of journal articles where resourcePrimKey = &#63;.
600            *
601            * @param resourcePrimKey the resource prim key
602            * @return the number of matching journal articles
603            */
604            public static int countByResourcePrimKey(long resourcePrimKey) {
605                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
606            }
607    
608            /**
609            * Returns all the journal articles where groupId = &#63;.
610            *
611            * @param groupId the group ID
612            * @return the matching journal articles
613            */
614            public static List<JournalArticle> findByGroupId(long groupId) {
615                    return getPersistence().findByGroupId(groupId);
616            }
617    
618            /**
619            * Returns a range of all the journal articles where groupId = &#63;.
620            *
621            * <p>
622            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
623            * </p>
624            *
625            * @param groupId the group ID
626            * @param start the lower bound of the range of journal articles
627            * @param end the upper bound of the range of journal articles (not inclusive)
628            * @return the range of matching journal articles
629            */
630            public static List<JournalArticle> findByGroupId(long groupId, int start,
631                    int end) {
632                    return getPersistence().findByGroupId(groupId, start, end);
633            }
634    
635            /**
636            * Returns an ordered range of all the journal articles where groupId = &#63;.
637            *
638            * <p>
639            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
640            * </p>
641            *
642            * @param groupId the group ID
643            * @param start the lower bound of the range of journal articles
644            * @param end the upper bound of the range of journal articles (not inclusive)
645            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
646            * @return the ordered range of matching journal articles
647            */
648            public static List<JournalArticle> findByGroupId(long groupId, int start,
649                    int end, OrderByComparator<JournalArticle> orderByComparator) {
650                    return getPersistence()
651                                       .findByGroupId(groupId, start, end, orderByComparator);
652            }
653    
654            /**
655            * Returns the first journal article in the ordered set where groupId = &#63;.
656            *
657            * @param groupId the group ID
658            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
659            * @return the first matching journal article
660            * @throws NoSuchArticleException if a matching journal article could not be found
661            */
662            public static JournalArticle findByGroupId_First(long groupId,
663                    OrderByComparator<JournalArticle> orderByComparator)
664                    throws com.liferay.portlet.journal.NoSuchArticleException {
665                    return getPersistence().findByGroupId_First(groupId, 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, or <code>null</code> if a matching journal article could not be found
674            */
675            public static JournalArticle fetchByGroupId_First(long groupId,
676                    OrderByComparator<JournalArticle> orderByComparator) {
677                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
678            }
679    
680            /**
681            * Returns the last journal article in the ordered set where groupId = &#63;.
682            *
683            * @param groupId the group ID
684            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
685            * @return the last matching journal article
686            * @throws NoSuchArticleException if a matching journal article could not be found
687            */
688            public static JournalArticle findByGroupId_Last(long groupId,
689                    OrderByComparator<JournalArticle> orderByComparator)
690                    throws com.liferay.portlet.journal.NoSuchArticleException {
691                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
692            }
693    
694            /**
695            * Returns the last journal article in the ordered set where groupId = &#63;.
696            *
697            * @param groupId the group ID
698            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
699            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
700            */
701            public static JournalArticle fetchByGroupId_Last(long groupId,
702                    OrderByComparator<JournalArticle> orderByComparator) {
703                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
704            }
705    
706            /**
707            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
708            *
709            * @param id the primary key of the current journal article
710            * @param groupId the group ID
711            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
712            * @return the previous, current, and next journal article
713            * @throws NoSuchArticleException if a journal article with the primary key could not be found
714            */
715            public static JournalArticle[] findByGroupId_PrevAndNext(long id,
716                    long groupId, OrderByComparator<JournalArticle> orderByComparator)
717                    throws com.liferay.portlet.journal.NoSuchArticleException {
718                    return getPersistence()
719                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
720            }
721    
722            /**
723            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
724            *
725            * @param groupId the group ID
726            * @return the matching journal articles that the user has permission to view
727            */
728            public static List<JournalArticle> filterFindByGroupId(long groupId) {
729                    return getPersistence().filterFindByGroupId(groupId);
730            }
731    
732            /**
733            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
734            *
735            * <p>
736            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
737            * </p>
738            *
739            * @param groupId the group ID
740            * @param start the lower bound of the range of journal articles
741            * @param end the upper bound of the range of journal articles (not inclusive)
742            * @return the range of matching journal articles that the user has permission to view
743            */
744            public static List<JournalArticle> filterFindByGroupId(long groupId,
745                    int start, int end) {
746                    return getPersistence().filterFindByGroupId(groupId, start, end);
747            }
748    
749            /**
750            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
751            *
752            * <p>
753            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
754            * </p>
755            *
756            * @param groupId the group ID
757            * @param start the lower bound of the range of journal articles
758            * @param end the upper bound of the range of journal articles (not inclusive)
759            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
760            * @return the ordered range of matching journal articles that the user has permission to view
761            */
762            public static List<JournalArticle> filterFindByGroupId(long groupId,
763                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
764                    return getPersistence()
765                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
766            }
767    
768            /**
769            * 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;.
770            *
771            * @param id the primary key of the current journal article
772            * @param groupId the group ID
773            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
774            * @return the previous, current, and next journal article
775            * @throws NoSuchArticleException if a journal article with the primary key could not be found
776            */
777            public static JournalArticle[] filterFindByGroupId_PrevAndNext(long id,
778                    long groupId, OrderByComparator<JournalArticle> orderByComparator)
779                    throws com.liferay.portlet.journal.NoSuchArticleException {
780                    return getPersistence()
781                                       .filterFindByGroupId_PrevAndNext(id, groupId,
782                            orderByComparator);
783            }
784    
785            /**
786            * Removes all the journal articles where groupId = &#63; from the database.
787            *
788            * @param groupId the group ID
789            */
790            public static void removeByGroupId(long groupId) {
791                    getPersistence().removeByGroupId(groupId);
792            }
793    
794            /**
795            * Returns the number of journal articles where groupId = &#63;.
796            *
797            * @param groupId the group ID
798            * @return the number of matching journal articles
799            */
800            public static int countByGroupId(long groupId) {
801                    return getPersistence().countByGroupId(groupId);
802            }
803    
804            /**
805            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
806            *
807            * @param groupId the group ID
808            * @return the number of matching journal articles that the user has permission to view
809            */
810            public static int filterCountByGroupId(long groupId) {
811                    return getPersistence().filterCountByGroupId(groupId);
812            }
813    
814            /**
815            * Returns all the journal articles where companyId = &#63;.
816            *
817            * @param companyId the company ID
818            * @return the matching journal articles
819            */
820            public static List<JournalArticle> findByCompanyId(long companyId) {
821                    return getPersistence().findByCompanyId(companyId);
822            }
823    
824            /**
825            * Returns a range of all the journal articles where companyId = &#63;.
826            *
827            * <p>
828            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
829            * </p>
830            *
831            * @param companyId the company ID
832            * @param start the lower bound of the range of journal articles
833            * @param end the upper bound of the range of journal articles (not inclusive)
834            * @return the range of matching journal articles
835            */
836            public static List<JournalArticle> findByCompanyId(long companyId,
837                    int start, int end) {
838                    return getPersistence().findByCompanyId(companyId, start, end);
839            }
840    
841            /**
842            * Returns an ordered range of all the journal articles where companyId = &#63;.
843            *
844            * <p>
845            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
846            * </p>
847            *
848            * @param companyId the company ID
849            * @param start the lower bound of the range of journal articles
850            * @param end the upper bound of the range of journal articles (not inclusive)
851            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
852            * @return the ordered range of matching journal articles
853            */
854            public static List<JournalArticle> findByCompanyId(long companyId,
855                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
856                    return getPersistence()
857                                       .findByCompanyId(companyId, start, end, orderByComparator);
858            }
859    
860            /**
861            * Returns the first journal article in the ordered set where companyId = &#63;.
862            *
863            * @param companyId the company ID
864            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
865            * @return the first matching journal article
866            * @throws NoSuchArticleException if a matching journal article could not be found
867            */
868            public static JournalArticle findByCompanyId_First(long companyId,
869                    OrderByComparator<JournalArticle> orderByComparator)
870                    throws com.liferay.portlet.journal.NoSuchArticleException {
871                    return getPersistence()
872                                       .findByCompanyId_First(companyId, orderByComparator);
873            }
874    
875            /**
876            * Returns the first journal article in the ordered set where companyId = &#63;.
877            *
878            * @param companyId the company ID
879            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
880            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
881            */
882            public static JournalArticle fetchByCompanyId_First(long companyId,
883                    OrderByComparator<JournalArticle> orderByComparator) {
884                    return getPersistence()
885                                       .fetchByCompanyId_First(companyId, orderByComparator);
886            }
887    
888            /**
889            * Returns the last journal article in the ordered set where companyId = &#63;.
890            *
891            * @param companyId the company ID
892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
893            * @return the last matching journal article
894            * @throws NoSuchArticleException if a matching journal article could not be found
895            */
896            public static JournalArticle findByCompanyId_Last(long companyId,
897                    OrderByComparator<JournalArticle> orderByComparator)
898                    throws com.liferay.portlet.journal.NoSuchArticleException {
899                    return getPersistence()
900                                       .findByCompanyId_Last(companyId, orderByComparator);
901            }
902    
903            /**
904            * Returns the last journal article in the ordered set where companyId = &#63;.
905            *
906            * @param companyId the company ID
907            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
908            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
909            */
910            public static JournalArticle fetchByCompanyId_Last(long companyId,
911                    OrderByComparator<JournalArticle> orderByComparator) {
912                    return getPersistence()
913                                       .fetchByCompanyId_Last(companyId, orderByComparator);
914            }
915    
916            /**
917            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
918            *
919            * @param id the primary key of the current journal article
920            * @param companyId the company ID
921            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
922            * @return the previous, current, and next journal article
923            * @throws NoSuchArticleException if a journal article with the primary key could not be found
924            */
925            public static JournalArticle[] findByCompanyId_PrevAndNext(long id,
926                    long companyId, OrderByComparator<JournalArticle> orderByComparator)
927                    throws com.liferay.portlet.journal.NoSuchArticleException {
928                    return getPersistence()
929                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
930            }
931    
932            /**
933            * Removes all the journal articles where companyId = &#63; from the database.
934            *
935            * @param companyId the company ID
936            */
937            public static void removeByCompanyId(long companyId) {
938                    getPersistence().removeByCompanyId(companyId);
939            }
940    
941            /**
942            * Returns the number of journal articles where companyId = &#63;.
943            *
944            * @param companyId the company ID
945            * @return the number of matching journal articles
946            */
947            public static int countByCompanyId(long companyId) {
948                    return getPersistence().countByCompanyId(companyId);
949            }
950    
951            /**
952            * Returns all the journal articles where DDMStructureKey = &#63;.
953            *
954            * @param DDMStructureKey the d d m structure key
955            * @return the matching journal articles
956            */
957            public static List<JournalArticle> findByDDMStructureKey(
958                    java.lang.String DDMStructureKey) {
959                    return getPersistence().findByDDMStructureKey(DDMStructureKey);
960            }
961    
962            /**
963            * Returns a range of all the journal articles where DDMStructureKey = &#63;.
964            *
965            * <p>
966            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
967            * </p>
968            *
969            * @param DDMStructureKey the d d m structure key
970            * @param start the lower bound of the range of journal articles
971            * @param end the upper bound of the range of journal articles (not inclusive)
972            * @return the range of matching journal articles
973            */
974            public static List<JournalArticle> findByDDMStructureKey(
975                    java.lang.String DDMStructureKey, int start, int end) {
976                    return getPersistence()
977                                       .findByDDMStructureKey(DDMStructureKey, start, end);
978            }
979    
980            /**
981            * Returns an ordered range of all the journal articles where DDMStructureKey = &#63;.
982            *
983            * <p>
984            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
985            * </p>
986            *
987            * @param DDMStructureKey the d d m structure key
988            * @param start the lower bound of the range of journal articles
989            * @param end the upper bound of the range of journal articles (not inclusive)
990            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
991            * @return the ordered range of matching journal articles
992            */
993            public static List<JournalArticle> findByDDMStructureKey(
994                    java.lang.String DDMStructureKey, int start, int end,
995                    OrderByComparator<JournalArticle> orderByComparator) {
996                    return getPersistence()
997                                       .findByDDMStructureKey(DDMStructureKey, start, end,
998                            orderByComparator);
999            }
1000    
1001            /**
1002            * Returns the first journal article in the ordered set where DDMStructureKey = &#63;.
1003            *
1004            * @param DDMStructureKey the d d m structure key
1005            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1006            * @return the first matching journal article
1007            * @throws NoSuchArticleException if a matching journal article could not be found
1008            */
1009            public static JournalArticle findByDDMStructureKey_First(
1010                    java.lang.String DDMStructureKey,
1011                    OrderByComparator<JournalArticle> orderByComparator)
1012                    throws com.liferay.portlet.journal.NoSuchArticleException {
1013                    return getPersistence()
1014                                       .findByDDMStructureKey_First(DDMStructureKey,
1015                            orderByComparator);
1016            }
1017    
1018            /**
1019            * Returns the first journal article in the ordered set where DDMStructureKey = &#63;.
1020            *
1021            * @param DDMStructureKey the d d m structure key
1022            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1023            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1024            */
1025            public static JournalArticle fetchByDDMStructureKey_First(
1026                    java.lang.String DDMStructureKey,
1027                    OrderByComparator<JournalArticle> orderByComparator) {
1028                    return getPersistence()
1029                                       .fetchByDDMStructureKey_First(DDMStructureKey,
1030                            orderByComparator);
1031            }
1032    
1033            /**
1034            * Returns the last journal article in the ordered set where DDMStructureKey = &#63;.
1035            *
1036            * @param DDMStructureKey the d d m structure key
1037            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1038            * @return the last matching journal article
1039            * @throws NoSuchArticleException if a matching journal article could not be found
1040            */
1041            public static JournalArticle findByDDMStructureKey_Last(
1042                    java.lang.String DDMStructureKey,
1043                    OrderByComparator<JournalArticle> orderByComparator)
1044                    throws com.liferay.portlet.journal.NoSuchArticleException {
1045                    return getPersistence()
1046                                       .findByDDMStructureKey_Last(DDMStructureKey,
1047                            orderByComparator);
1048            }
1049    
1050            /**
1051            * Returns the last journal article in the ordered set where DDMStructureKey = &#63;.
1052            *
1053            * @param DDMStructureKey the d d m structure key
1054            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1055            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1056            */
1057            public static JournalArticle fetchByDDMStructureKey_Last(
1058                    java.lang.String DDMStructureKey,
1059                    OrderByComparator<JournalArticle> orderByComparator) {
1060                    return getPersistence()
1061                                       .fetchByDDMStructureKey_Last(DDMStructureKey,
1062                            orderByComparator);
1063            }
1064    
1065            /**
1066            * Returns the journal articles before and after the current journal article in the ordered set where DDMStructureKey = &#63;.
1067            *
1068            * @param id the primary key of the current journal article
1069            * @param DDMStructureKey the d d m structure key
1070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1071            * @return the previous, current, and next journal article
1072            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1073            */
1074            public static JournalArticle[] findByDDMStructureKey_PrevAndNext(long id,
1075                    java.lang.String DDMStructureKey,
1076                    OrderByComparator<JournalArticle> orderByComparator)
1077                    throws com.liferay.portlet.journal.NoSuchArticleException {
1078                    return getPersistence()
1079                                       .findByDDMStructureKey_PrevAndNext(id, DDMStructureKey,
1080                            orderByComparator);
1081            }
1082    
1083            /**
1084            * Returns all the journal articles where DDMStructureKey = any &#63;.
1085            *
1086            * <p>
1087            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1088            * </p>
1089            *
1090            * @param DDMStructureKeies the d d m structure keies
1091            * @return the matching journal articles
1092            */
1093            public static List<JournalArticle> findByDDMStructureKey(
1094                    java.lang.String[] DDMStructureKeies) {
1095                    return getPersistence().findByDDMStructureKey(DDMStructureKeies);
1096            }
1097    
1098            /**
1099            * Returns a range of all the journal articles where DDMStructureKey = any &#63;.
1100            *
1101            * <p>
1102            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1103            * </p>
1104            *
1105            * @param DDMStructureKeies the d d m structure keies
1106            * @param start the lower bound of the range of journal articles
1107            * @param end the upper bound of the range of journal articles (not inclusive)
1108            * @return the range of matching journal articles
1109            */
1110            public static List<JournalArticle> findByDDMStructureKey(
1111                    java.lang.String[] DDMStructureKeies, int start, int end) {
1112                    return getPersistence()
1113                                       .findByDDMStructureKey(DDMStructureKeies, start, end);
1114            }
1115    
1116            /**
1117            * Returns an ordered range of all the journal articles where DDMStructureKey = any &#63;.
1118            *
1119            * <p>
1120            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1121            * </p>
1122            *
1123            * @param DDMStructureKeies the d d m structure keies
1124            * @param start the lower bound of the range of journal articles
1125            * @param end the upper bound of the range of journal articles (not inclusive)
1126            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1127            * @return the ordered range of matching journal articles
1128            */
1129            public static List<JournalArticle> findByDDMStructureKey(
1130                    java.lang.String[] DDMStructureKeies, int start, int end,
1131                    OrderByComparator<JournalArticle> orderByComparator) {
1132                    return getPersistence()
1133                                       .findByDDMStructureKey(DDMStructureKeies, start, end,
1134                            orderByComparator);
1135            }
1136    
1137            /**
1138            * Removes all the journal articles where DDMStructureKey = &#63; from the database.
1139            *
1140            * @param DDMStructureKey the d d m structure key
1141            */
1142            public static void removeByDDMStructureKey(java.lang.String DDMStructureKey) {
1143                    getPersistence().removeByDDMStructureKey(DDMStructureKey);
1144            }
1145    
1146            /**
1147            * Returns the number of journal articles where DDMStructureKey = &#63;.
1148            *
1149            * @param DDMStructureKey the d d m structure key
1150            * @return the number of matching journal articles
1151            */
1152            public static int countByDDMStructureKey(java.lang.String DDMStructureKey) {
1153                    return getPersistence().countByDDMStructureKey(DDMStructureKey);
1154            }
1155    
1156            /**
1157            * Returns the number of journal articles where DDMStructureKey = any &#63;.
1158            *
1159            * @param DDMStructureKeies the d d m structure keies
1160            * @return the number of matching journal articles
1161            */
1162            public static int countByDDMStructureKey(
1163                    java.lang.String[] DDMStructureKeies) {
1164                    return getPersistence().countByDDMStructureKey(DDMStructureKeies);
1165            }
1166    
1167            /**
1168            * Returns all the journal articles where DDMTemplateKey = &#63;.
1169            *
1170            * @param DDMTemplateKey the d d m template key
1171            * @return the matching journal articles
1172            */
1173            public static List<JournalArticle> findByDDMTemplateKey(
1174                    java.lang.String DDMTemplateKey) {
1175                    return getPersistence().findByDDMTemplateKey(DDMTemplateKey);
1176            }
1177    
1178            /**
1179            * Returns a range of all the journal articles where DDMTemplateKey = &#63;.
1180            *
1181            * <p>
1182            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1183            * </p>
1184            *
1185            * @param DDMTemplateKey the d d m template key
1186            * @param start the lower bound of the range of journal articles
1187            * @param end the upper bound of the range of journal articles (not inclusive)
1188            * @return the range of matching journal articles
1189            */
1190            public static List<JournalArticle> findByDDMTemplateKey(
1191                    java.lang.String DDMTemplateKey, int start, int end) {
1192                    return getPersistence().findByDDMTemplateKey(DDMTemplateKey, start, end);
1193            }
1194    
1195            /**
1196            * Returns an ordered range of all the journal articles where DDMTemplateKey = &#63;.
1197            *
1198            * <p>
1199            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1200            * </p>
1201            *
1202            * @param DDMTemplateKey the d d m template key
1203            * @param start the lower bound of the range of journal articles
1204            * @param end the upper bound of the range of journal articles (not inclusive)
1205            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1206            * @return the ordered range of matching journal articles
1207            */
1208            public static List<JournalArticle> findByDDMTemplateKey(
1209                    java.lang.String DDMTemplateKey, int start, int end,
1210                    OrderByComparator<JournalArticle> orderByComparator) {
1211                    return getPersistence()
1212                                       .findByDDMTemplateKey(DDMTemplateKey, start, end,
1213                            orderByComparator);
1214            }
1215    
1216            /**
1217            * Returns the first journal article in the ordered set where DDMTemplateKey = &#63;.
1218            *
1219            * @param DDMTemplateKey the d d m template key
1220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1221            * @return the first matching journal article
1222            * @throws NoSuchArticleException if a matching journal article could not be found
1223            */
1224            public static JournalArticle findByDDMTemplateKey_First(
1225                    java.lang.String DDMTemplateKey,
1226                    OrderByComparator<JournalArticle> orderByComparator)
1227                    throws com.liferay.portlet.journal.NoSuchArticleException {
1228                    return getPersistence()
1229                                       .findByDDMTemplateKey_First(DDMTemplateKey, orderByComparator);
1230            }
1231    
1232            /**
1233            * Returns the first journal article in the ordered set where DDMTemplateKey = &#63;.
1234            *
1235            * @param DDMTemplateKey the d d m template key
1236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1237            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1238            */
1239            public static JournalArticle fetchByDDMTemplateKey_First(
1240                    java.lang.String DDMTemplateKey,
1241                    OrderByComparator<JournalArticle> orderByComparator) {
1242                    return getPersistence()
1243                                       .fetchByDDMTemplateKey_First(DDMTemplateKey,
1244                            orderByComparator);
1245            }
1246    
1247            /**
1248            * Returns the last journal article in the ordered set where DDMTemplateKey = &#63;.
1249            *
1250            * @param DDMTemplateKey the d d m template key
1251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1252            * @return the last matching journal article
1253            * @throws NoSuchArticleException if a matching journal article could not be found
1254            */
1255            public static JournalArticle findByDDMTemplateKey_Last(
1256                    java.lang.String DDMTemplateKey,
1257                    OrderByComparator<JournalArticle> orderByComparator)
1258                    throws com.liferay.portlet.journal.NoSuchArticleException {
1259                    return getPersistence()
1260                                       .findByDDMTemplateKey_Last(DDMTemplateKey, orderByComparator);
1261            }
1262    
1263            /**
1264            * Returns the last journal article in the ordered set where DDMTemplateKey = &#63;.
1265            *
1266            * @param DDMTemplateKey the d d m template key
1267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1268            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1269            */
1270            public static JournalArticle fetchByDDMTemplateKey_Last(
1271                    java.lang.String DDMTemplateKey,
1272                    OrderByComparator<JournalArticle> orderByComparator) {
1273                    return getPersistence()
1274                                       .fetchByDDMTemplateKey_Last(DDMTemplateKey, orderByComparator);
1275            }
1276    
1277            /**
1278            * Returns the journal articles before and after the current journal article in the ordered set where DDMTemplateKey = &#63;.
1279            *
1280            * @param id the primary key of the current journal article
1281            * @param DDMTemplateKey the d d m template key
1282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1283            * @return the previous, current, and next journal article
1284            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1285            */
1286            public static JournalArticle[] findByDDMTemplateKey_PrevAndNext(long id,
1287                    java.lang.String DDMTemplateKey,
1288                    OrderByComparator<JournalArticle> orderByComparator)
1289                    throws com.liferay.portlet.journal.NoSuchArticleException {
1290                    return getPersistence()
1291                                       .findByDDMTemplateKey_PrevAndNext(id, DDMTemplateKey,
1292                            orderByComparator);
1293            }
1294    
1295            /**
1296            * Removes all the journal articles where DDMTemplateKey = &#63; from the database.
1297            *
1298            * @param DDMTemplateKey the d d m template key
1299            */
1300            public static void removeByDDMTemplateKey(java.lang.String DDMTemplateKey) {
1301                    getPersistence().removeByDDMTemplateKey(DDMTemplateKey);
1302            }
1303    
1304            /**
1305            * Returns the number of journal articles where DDMTemplateKey = &#63;.
1306            *
1307            * @param DDMTemplateKey the d d m template key
1308            * @return the number of matching journal articles
1309            */
1310            public static int countByDDMTemplateKey(java.lang.String DDMTemplateKey) {
1311                    return getPersistence().countByDDMTemplateKey(DDMTemplateKey);
1312            }
1313    
1314            /**
1315            * Returns all the journal articles where layoutUuid = &#63;.
1316            *
1317            * @param layoutUuid the layout uuid
1318            * @return the matching journal articles
1319            */
1320            public static List<JournalArticle> findByLayoutUuid(
1321                    java.lang.String layoutUuid) {
1322                    return getPersistence().findByLayoutUuid(layoutUuid);
1323            }
1324    
1325            /**
1326            * Returns a range of all the journal articles where layoutUuid = &#63;.
1327            *
1328            * <p>
1329            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1330            * </p>
1331            *
1332            * @param layoutUuid the layout uuid
1333            * @param start the lower bound of the range of journal articles
1334            * @param end the upper bound of the range of journal articles (not inclusive)
1335            * @return the range of matching journal articles
1336            */
1337            public static List<JournalArticle> findByLayoutUuid(
1338                    java.lang.String layoutUuid, int start, int end) {
1339                    return getPersistence().findByLayoutUuid(layoutUuid, start, end);
1340            }
1341    
1342            /**
1343            * Returns an ordered range of all the journal articles where layoutUuid = &#63;.
1344            *
1345            * <p>
1346            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1347            * </p>
1348            *
1349            * @param layoutUuid the layout uuid
1350            * @param start the lower bound of the range of journal articles
1351            * @param end the upper bound of the range of journal articles (not inclusive)
1352            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1353            * @return the ordered range of matching journal articles
1354            */
1355            public static List<JournalArticle> findByLayoutUuid(
1356                    java.lang.String layoutUuid, int start, int end,
1357                    OrderByComparator<JournalArticle> orderByComparator) {
1358                    return getPersistence()
1359                                       .findByLayoutUuid(layoutUuid, start, end, orderByComparator);
1360            }
1361    
1362            /**
1363            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1364            *
1365            * @param layoutUuid the layout uuid
1366            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1367            * @return the first matching journal article
1368            * @throws NoSuchArticleException if a matching journal article could not be found
1369            */
1370            public static JournalArticle findByLayoutUuid_First(
1371                    java.lang.String layoutUuid,
1372                    OrderByComparator<JournalArticle> orderByComparator)
1373                    throws com.liferay.portlet.journal.NoSuchArticleException {
1374                    return getPersistence()
1375                                       .findByLayoutUuid_First(layoutUuid, orderByComparator);
1376            }
1377    
1378            /**
1379            * Returns the first journal article in the ordered set where layoutUuid = &#63;.
1380            *
1381            * @param layoutUuid the layout uuid
1382            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1383            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1384            */
1385            public static JournalArticle fetchByLayoutUuid_First(
1386                    java.lang.String layoutUuid,
1387                    OrderByComparator<JournalArticle> orderByComparator) {
1388                    return getPersistence()
1389                                       .fetchByLayoutUuid_First(layoutUuid, orderByComparator);
1390            }
1391    
1392            /**
1393            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1394            *
1395            * @param layoutUuid the layout uuid
1396            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1397            * @return the last matching journal article
1398            * @throws NoSuchArticleException if a matching journal article could not be found
1399            */
1400            public static JournalArticle findByLayoutUuid_Last(
1401                    java.lang.String layoutUuid,
1402                    OrderByComparator<JournalArticle> orderByComparator)
1403                    throws com.liferay.portlet.journal.NoSuchArticleException {
1404                    return getPersistence()
1405                                       .findByLayoutUuid_Last(layoutUuid, orderByComparator);
1406            }
1407    
1408            /**
1409            * Returns the last journal article in the ordered set where layoutUuid = &#63;.
1410            *
1411            * @param layoutUuid the layout uuid
1412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1413            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1414            */
1415            public static JournalArticle fetchByLayoutUuid_Last(
1416                    java.lang.String layoutUuid,
1417                    OrderByComparator<JournalArticle> orderByComparator) {
1418                    return getPersistence()
1419                                       .fetchByLayoutUuid_Last(layoutUuid, orderByComparator);
1420            }
1421    
1422            /**
1423            * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = &#63;.
1424            *
1425            * @param id the primary key of the current journal article
1426            * @param layoutUuid the layout uuid
1427            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1428            * @return the previous, current, and next journal article
1429            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1430            */
1431            public static JournalArticle[] findByLayoutUuid_PrevAndNext(long id,
1432                    java.lang.String layoutUuid,
1433                    OrderByComparator<JournalArticle> orderByComparator)
1434                    throws com.liferay.portlet.journal.NoSuchArticleException {
1435                    return getPersistence()
1436                                       .findByLayoutUuid_PrevAndNext(id, layoutUuid,
1437                            orderByComparator);
1438            }
1439    
1440            /**
1441            * Removes all the journal articles where layoutUuid = &#63; from the database.
1442            *
1443            * @param layoutUuid the layout uuid
1444            */
1445            public static void removeByLayoutUuid(java.lang.String layoutUuid) {
1446                    getPersistence().removeByLayoutUuid(layoutUuid);
1447            }
1448    
1449            /**
1450            * Returns the number of journal articles where layoutUuid = &#63;.
1451            *
1452            * @param layoutUuid the layout uuid
1453            * @return the number of matching journal articles
1454            */
1455            public static int countByLayoutUuid(java.lang.String layoutUuid) {
1456                    return getPersistence().countByLayoutUuid(layoutUuid);
1457            }
1458    
1459            /**
1460            * Returns all the journal articles where smallImageId = &#63;.
1461            *
1462            * @param smallImageId the small image ID
1463            * @return the matching journal articles
1464            */
1465            public static List<JournalArticle> findBySmallImageId(long smallImageId) {
1466                    return getPersistence().findBySmallImageId(smallImageId);
1467            }
1468    
1469            /**
1470            * Returns a range of all the journal articles where smallImageId = &#63;.
1471            *
1472            * <p>
1473            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1474            * </p>
1475            *
1476            * @param smallImageId the small image ID
1477            * @param start the lower bound of the range of journal articles
1478            * @param end the upper bound of the range of journal articles (not inclusive)
1479            * @return the range of matching journal articles
1480            */
1481            public static List<JournalArticle> findBySmallImageId(long smallImageId,
1482                    int start, int end) {
1483                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1484            }
1485    
1486            /**
1487            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1488            *
1489            * <p>
1490            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1491            * </p>
1492            *
1493            * @param smallImageId the small image ID
1494            * @param start the lower bound of the range of journal articles
1495            * @param end the upper bound of the range of journal articles (not inclusive)
1496            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1497            * @return the ordered range of matching journal articles
1498            */
1499            public static List<JournalArticle> findBySmallImageId(long smallImageId,
1500                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
1501                    return getPersistence()
1502                                       .findBySmallImageId(smallImageId, start, end,
1503                            orderByComparator);
1504            }
1505    
1506            /**
1507            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1508            *
1509            * @param smallImageId the small image ID
1510            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1511            * @return the first matching journal article
1512            * @throws NoSuchArticleException if a matching journal article could not be found
1513            */
1514            public static JournalArticle findBySmallImageId_First(long smallImageId,
1515                    OrderByComparator<JournalArticle> orderByComparator)
1516                    throws com.liferay.portlet.journal.NoSuchArticleException {
1517                    return getPersistence()
1518                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1519            }
1520    
1521            /**
1522            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1523            *
1524            * @param smallImageId the small image ID
1525            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1526            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1527            */
1528            public static JournalArticle fetchBySmallImageId_First(long smallImageId,
1529                    OrderByComparator<JournalArticle> orderByComparator) {
1530                    return getPersistence()
1531                                       .fetchBySmallImageId_First(smallImageId, orderByComparator);
1532            }
1533    
1534            /**
1535            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1536            *
1537            * @param smallImageId the small image ID
1538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1539            * @return the last matching journal article
1540            * @throws NoSuchArticleException if a matching journal article could not be found
1541            */
1542            public static JournalArticle findBySmallImageId_Last(long smallImageId,
1543                    OrderByComparator<JournalArticle> orderByComparator)
1544                    throws com.liferay.portlet.journal.NoSuchArticleException {
1545                    return getPersistence()
1546                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1547            }
1548    
1549            /**
1550            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1551            *
1552            * @param smallImageId the small image ID
1553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1554            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1555            */
1556            public static JournalArticle fetchBySmallImageId_Last(long smallImageId,
1557                    OrderByComparator<JournalArticle> orderByComparator) {
1558                    return getPersistence()
1559                                       .fetchBySmallImageId_Last(smallImageId, orderByComparator);
1560            }
1561    
1562            /**
1563            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1564            *
1565            * @param id the primary key of the current journal article
1566            * @param smallImageId the small image ID
1567            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1568            * @return the previous, current, and next journal article
1569            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1570            */
1571            public static JournalArticle[] findBySmallImageId_PrevAndNext(long id,
1572                    long smallImageId, OrderByComparator<JournalArticle> orderByComparator)
1573                    throws com.liferay.portlet.journal.NoSuchArticleException {
1574                    return getPersistence()
1575                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1576                            orderByComparator);
1577            }
1578    
1579            /**
1580            * Removes all the journal articles where smallImageId = &#63; from the database.
1581            *
1582            * @param smallImageId the small image ID
1583            */
1584            public static void removeBySmallImageId(long smallImageId) {
1585                    getPersistence().removeBySmallImageId(smallImageId);
1586            }
1587    
1588            /**
1589            * Returns the number of journal articles where smallImageId = &#63;.
1590            *
1591            * @param smallImageId the small image ID
1592            * @return the number of matching journal articles
1593            */
1594            public static int countBySmallImageId(long smallImageId) {
1595                    return getPersistence().countBySmallImageId(smallImageId);
1596            }
1597    
1598            /**
1599            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1600            *
1601            * @param resourcePrimKey the resource prim key
1602            * @param indexable the indexable
1603            * @return the matching journal articles
1604            */
1605            public static List<JournalArticle> findByR_I(long resourcePrimKey,
1606                    boolean indexable) {
1607                    return getPersistence().findByR_I(resourcePrimKey, indexable);
1608            }
1609    
1610            /**
1611            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1612            *
1613            * <p>
1614            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1615            * </p>
1616            *
1617            * @param resourcePrimKey the resource prim key
1618            * @param indexable the indexable
1619            * @param start the lower bound of the range of journal articles
1620            * @param end the upper bound of the range of journal articles (not inclusive)
1621            * @return the range of matching journal articles
1622            */
1623            public static List<JournalArticle> findByR_I(long resourcePrimKey,
1624                    boolean indexable, int start, int end) {
1625                    return getPersistence().findByR_I(resourcePrimKey, indexable, start, end);
1626            }
1627    
1628            /**
1629            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1630            *
1631            * <p>
1632            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1633            * </p>
1634            *
1635            * @param resourcePrimKey the resource prim key
1636            * @param indexable the indexable
1637            * @param start the lower bound of the range of journal articles
1638            * @param end the upper bound of the range of journal articles (not inclusive)
1639            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1640            * @return the ordered range of matching journal articles
1641            */
1642            public static List<JournalArticle> findByR_I(long resourcePrimKey,
1643                    boolean indexable, int start, int end,
1644                    OrderByComparator<JournalArticle> orderByComparator) {
1645                    return getPersistence()
1646                                       .findByR_I(resourcePrimKey, indexable, start, end,
1647                            orderByComparator);
1648            }
1649    
1650            /**
1651            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1652            *
1653            * @param resourcePrimKey the resource prim key
1654            * @param indexable the indexable
1655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1656            * @return the first matching journal article
1657            * @throws NoSuchArticleException if a matching journal article could not be found
1658            */
1659            public static JournalArticle findByR_I_First(long resourcePrimKey,
1660                    boolean indexable, OrderByComparator<JournalArticle> orderByComparator)
1661                    throws com.liferay.portlet.journal.NoSuchArticleException {
1662                    return getPersistence()
1663                                       .findByR_I_First(resourcePrimKey, indexable,
1664                            orderByComparator);
1665            }
1666    
1667            /**
1668            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1669            *
1670            * @param resourcePrimKey the resource prim key
1671            * @param indexable the indexable
1672            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1673            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1674            */
1675            public static JournalArticle fetchByR_I_First(long resourcePrimKey,
1676                    boolean indexable, OrderByComparator<JournalArticle> orderByComparator) {
1677                    return getPersistence()
1678                                       .fetchByR_I_First(resourcePrimKey, indexable,
1679                            orderByComparator);
1680            }
1681    
1682            /**
1683            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1684            *
1685            * @param resourcePrimKey the resource prim key
1686            * @param indexable the indexable
1687            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1688            * @return the last matching journal article
1689            * @throws NoSuchArticleException if a matching journal article could not be found
1690            */
1691            public static JournalArticle findByR_I_Last(long resourcePrimKey,
1692                    boolean indexable, OrderByComparator<JournalArticle> orderByComparator)
1693                    throws com.liferay.portlet.journal.NoSuchArticleException {
1694                    return getPersistence()
1695                                       .findByR_I_Last(resourcePrimKey, indexable, orderByComparator);
1696            }
1697    
1698            /**
1699            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1700            *
1701            * @param resourcePrimKey the resource prim key
1702            * @param indexable the indexable
1703            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1704            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1705            */
1706            public static JournalArticle fetchByR_I_Last(long resourcePrimKey,
1707                    boolean indexable, OrderByComparator<JournalArticle> orderByComparator) {
1708                    return getPersistence()
1709                                       .fetchByR_I_Last(resourcePrimKey, indexable,
1710                            orderByComparator);
1711            }
1712    
1713            /**
1714            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63;.
1715            *
1716            * @param id the primary key of the current journal article
1717            * @param resourcePrimKey the resource prim key
1718            * @param indexable the indexable
1719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1720            * @return the previous, current, and next journal article
1721            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1722            */
1723            public static JournalArticle[] findByR_I_PrevAndNext(long id,
1724                    long resourcePrimKey, boolean indexable,
1725                    OrderByComparator<JournalArticle> orderByComparator)
1726                    throws com.liferay.portlet.journal.NoSuchArticleException {
1727                    return getPersistence()
1728                                       .findByR_I_PrevAndNext(id, resourcePrimKey, indexable,
1729                            orderByComparator);
1730            }
1731    
1732            /**
1733            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; from the database.
1734            *
1735            * @param resourcePrimKey the resource prim key
1736            * @param indexable the indexable
1737            */
1738            public static void removeByR_I(long resourcePrimKey, boolean indexable) {
1739                    getPersistence().removeByR_I(resourcePrimKey, indexable);
1740            }
1741    
1742            /**
1743            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63;.
1744            *
1745            * @param resourcePrimKey the resource prim key
1746            * @param indexable the indexable
1747            * @return the number of matching journal articles
1748            */
1749            public static int countByR_I(long resourcePrimKey, boolean indexable) {
1750                    return getPersistence().countByR_I(resourcePrimKey, indexable);
1751            }
1752    
1753            /**
1754            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1755            *
1756            * @param resourcePrimKey the resource prim key
1757            * @param status the status
1758            * @return the matching journal articles
1759            */
1760            public static List<JournalArticle> findByR_ST(long resourcePrimKey,
1761                    int status) {
1762                    return getPersistence().findByR_ST(resourcePrimKey, status);
1763            }
1764    
1765            /**
1766            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1767            *
1768            * <p>
1769            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1770            * </p>
1771            *
1772            * @param resourcePrimKey the resource prim key
1773            * @param status the status
1774            * @param start the lower bound of the range of journal articles
1775            * @param end the upper bound of the range of journal articles (not inclusive)
1776            * @return the range of matching journal articles
1777            */
1778            public static List<JournalArticle> findByR_ST(long resourcePrimKey,
1779                    int status, int start, int end) {
1780                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1781            }
1782    
1783            /**
1784            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1785            *
1786            * <p>
1787            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1788            * </p>
1789            *
1790            * @param resourcePrimKey the resource prim key
1791            * @param status the status
1792            * @param start the lower bound of the range of journal articles
1793            * @param end the upper bound of the range of journal articles (not inclusive)
1794            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1795            * @return the ordered range of matching journal articles
1796            */
1797            public static List<JournalArticle> findByR_ST(long resourcePrimKey,
1798                    int status, int start, int end,
1799                    OrderByComparator<JournalArticle> orderByComparator) {
1800                    return getPersistence()
1801                                       .findByR_ST(resourcePrimKey, status, start, end,
1802                            orderByComparator);
1803            }
1804    
1805            /**
1806            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1807            *
1808            * @param resourcePrimKey the resource prim key
1809            * @param status the status
1810            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1811            * @return the first matching journal article
1812            * @throws NoSuchArticleException if a matching journal article could not be found
1813            */
1814            public static JournalArticle findByR_ST_First(long resourcePrimKey,
1815                    int status, OrderByComparator<JournalArticle> orderByComparator)
1816                    throws com.liferay.portlet.journal.NoSuchArticleException {
1817                    return getPersistence()
1818                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1819            }
1820    
1821            /**
1822            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1823            *
1824            * @param resourcePrimKey the resource prim key
1825            * @param status the status
1826            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1827            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
1828            */
1829            public static JournalArticle fetchByR_ST_First(long resourcePrimKey,
1830                    int status, OrderByComparator<JournalArticle> orderByComparator) {
1831                    return getPersistence()
1832                                       .fetchByR_ST_First(resourcePrimKey, status, orderByComparator);
1833            }
1834    
1835            /**
1836            * Returns the last 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 last matching journal article
1842            * @throws NoSuchArticleException if a matching journal article could not be found
1843            */
1844            public static JournalArticle findByR_ST_Last(long resourcePrimKey,
1845                    int status, OrderByComparator<JournalArticle> orderByComparator)
1846                    throws com.liferay.portlet.journal.NoSuchArticleException {
1847                    return getPersistence()
1848                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1849            }
1850    
1851            /**
1852            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1853            *
1854            * @param resourcePrimKey the resource prim key
1855            * @param status the status
1856            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1857            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
1858            */
1859            public static JournalArticle fetchByR_ST_Last(long resourcePrimKey,
1860                    int status, OrderByComparator<JournalArticle> orderByComparator) {
1861                    return getPersistence()
1862                                       .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator);
1863            }
1864    
1865            /**
1866            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1867            *
1868            * @param id the primary key of the current journal article
1869            * @param resourcePrimKey the resource prim key
1870            * @param status the status
1871            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1872            * @return the previous, current, and next journal article
1873            * @throws NoSuchArticleException if a journal article with the primary key could not be found
1874            */
1875            public static JournalArticle[] findByR_ST_PrevAndNext(long id,
1876                    long resourcePrimKey, int status,
1877                    OrderByComparator<JournalArticle> orderByComparator)
1878                    throws com.liferay.portlet.journal.NoSuchArticleException {
1879                    return getPersistence()
1880                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1881                            orderByComparator);
1882            }
1883    
1884            /**
1885            * Returns all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1886            *
1887            * <p>
1888            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1889            * </p>
1890            *
1891            * @param resourcePrimKey the resource prim key
1892            * @param statuses the statuses
1893            * @return the matching journal articles
1894            */
1895            public static List<JournalArticle> findByR_ST(long resourcePrimKey,
1896                    int[] statuses) {
1897                    return getPersistence().findByR_ST(resourcePrimKey, statuses);
1898            }
1899    
1900            /**
1901            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = any &#63;.
1902            *
1903            * <p>
1904            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1905            * </p>
1906            *
1907            * @param resourcePrimKey the resource prim key
1908            * @param statuses the statuses
1909            * @param start the lower bound of the range of journal articles
1910            * @param end the upper bound of the range of journal articles (not inclusive)
1911            * @return the range of matching journal articles
1912            */
1913            public static List<JournalArticle> findByR_ST(long resourcePrimKey,
1914                    int[] statuses, int start, int end) {
1915                    return getPersistence().findByR_ST(resourcePrimKey, statuses, start, end);
1916            }
1917    
1918            /**
1919            * Returns an ordered range of 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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            * @param start the lower bound of the range of journal articles
1928            * @param end the upper bound of the range of journal articles (not inclusive)
1929            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1930            * @return the ordered range of matching journal articles
1931            */
1932            public static List<JournalArticle> findByR_ST(long resourcePrimKey,
1933                    int[] statuses, int start, int end,
1934                    OrderByComparator<JournalArticle> orderByComparator) {
1935                    return getPersistence()
1936                                       .findByR_ST(resourcePrimKey, statuses, start, end,
1937                            orderByComparator);
1938            }
1939    
1940            /**
1941            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
1942            *
1943            * @param resourcePrimKey the resource prim key
1944            * @param status the status
1945            */
1946            public static void removeByR_ST(long resourcePrimKey, int status) {
1947                    getPersistence().removeByR_ST(resourcePrimKey, status);
1948            }
1949    
1950            /**
1951            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
1952            *
1953            * @param resourcePrimKey the resource prim key
1954            * @param status the status
1955            * @return the number of matching journal articles
1956            */
1957            public static int countByR_ST(long resourcePrimKey, int status) {
1958                    return getPersistence().countByR_ST(resourcePrimKey, status);
1959            }
1960    
1961            /**
1962            * Returns the number of journal articles where resourcePrimKey = &#63; and status = any &#63;.
1963            *
1964            * @param resourcePrimKey the resource prim key
1965            * @param statuses the statuses
1966            * @return the number of matching journal articles
1967            */
1968            public static int countByR_ST(long resourcePrimKey, int[] statuses) {
1969                    return getPersistence().countByR_ST(resourcePrimKey, statuses);
1970            }
1971    
1972            /**
1973            * Returns all the journal articles where groupId = &#63; and userId = &#63;.
1974            *
1975            * @param groupId the group ID
1976            * @param userId the user ID
1977            * @return the matching journal articles
1978            */
1979            public static List<JournalArticle> findByG_U(long groupId, long userId) {
1980                    return getPersistence().findByG_U(groupId, userId);
1981            }
1982    
1983            /**
1984            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63;.
1985            *
1986            * <p>
1987            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1988            * </p>
1989            *
1990            * @param groupId the group ID
1991            * @param userId the user ID
1992            * @param start the lower bound of the range of journal articles
1993            * @param end the upper bound of the range of journal articles (not inclusive)
1994            * @return the range of matching journal articles
1995            */
1996            public static List<JournalArticle> findByG_U(long groupId, long userId,
1997                    int start, int end) {
1998                    return getPersistence().findByG_U(groupId, userId, start, end);
1999            }
2000    
2001            /**
2002            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63;.
2003            *
2004            * <p>
2005            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2006            * </p>
2007            *
2008            * @param groupId the group ID
2009            * @param userId the user ID
2010            * @param start the lower bound of the range of journal articles
2011            * @param end the upper bound of the range of journal articles (not inclusive)
2012            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2013            * @return the ordered range of matching journal articles
2014            */
2015            public static List<JournalArticle> findByG_U(long groupId, long userId,
2016                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
2017                    return getPersistence()
2018                                       .findByG_U(groupId, userId, start, end, orderByComparator);
2019            }
2020    
2021            /**
2022            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2023            *
2024            * @param groupId the group ID
2025            * @param userId the user ID
2026            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2027            * @return the first matching journal article
2028            * @throws NoSuchArticleException if a matching journal article could not be found
2029            */
2030            public static JournalArticle findByG_U_First(long groupId, long userId,
2031                    OrderByComparator<JournalArticle> orderByComparator)
2032                    throws com.liferay.portlet.journal.NoSuchArticleException {
2033                    return getPersistence()
2034                                       .findByG_U_First(groupId, userId, orderByComparator);
2035            }
2036    
2037            /**
2038            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63;.
2039            *
2040            * @param groupId the group ID
2041            * @param userId the user ID
2042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2043            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2044            */
2045            public static JournalArticle fetchByG_U_First(long groupId, long userId,
2046                    OrderByComparator<JournalArticle> orderByComparator) {
2047                    return getPersistence()
2048                                       .fetchByG_U_First(groupId, userId, orderByComparator);
2049            }
2050    
2051            /**
2052            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2053            *
2054            * @param groupId the group ID
2055            * @param userId the user ID
2056            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2057            * @return the last matching journal article
2058            * @throws NoSuchArticleException if a matching journal article could not be found
2059            */
2060            public static JournalArticle findByG_U_Last(long groupId, long userId,
2061                    OrderByComparator<JournalArticle> orderByComparator)
2062                    throws com.liferay.portlet.journal.NoSuchArticleException {
2063                    return getPersistence()
2064                                       .findByG_U_Last(groupId, userId, orderByComparator);
2065            }
2066    
2067            /**
2068            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63;.
2069            *
2070            * @param groupId the group ID
2071            * @param userId the user ID
2072            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2073            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2074            */
2075            public static JournalArticle fetchByG_U_Last(long groupId, long userId,
2076                    OrderByComparator<JournalArticle> orderByComparator) {
2077                    return getPersistence()
2078                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
2079            }
2080    
2081            /**
2082            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63;.
2083            *
2084            * @param id the primary key of the current journal article
2085            * @param groupId the group ID
2086            * @param userId the user ID
2087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2088            * @return the previous, current, and next journal article
2089            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2090            */
2091            public static JournalArticle[] findByG_U_PrevAndNext(long id, long groupId,
2092                    long userId, OrderByComparator<JournalArticle> orderByComparator)
2093                    throws com.liferay.portlet.journal.NoSuchArticleException {
2094                    return getPersistence()
2095                                       .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator);
2096            }
2097    
2098            /**
2099            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2100            *
2101            * @param groupId the group ID
2102            * @param userId the user ID
2103            * @return the matching journal articles that the user has permission to view
2104            */
2105            public static List<JournalArticle> filterFindByG_U(long groupId, long userId) {
2106                    return getPersistence().filterFindByG_U(groupId, userId);
2107            }
2108    
2109            /**
2110            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2111            *
2112            * <p>
2113            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2114            * </p>
2115            *
2116            * @param groupId the group ID
2117            * @param userId the user ID
2118            * @param start the lower bound of the range of journal articles
2119            * @param end the upper bound of the range of journal articles (not inclusive)
2120            * @return the range of matching journal articles that the user has permission to view
2121            */
2122            public static List<JournalArticle> filterFindByG_U(long groupId,
2123                    long userId, int start, int end) {
2124                    return getPersistence().filterFindByG_U(groupId, userId, start, end);
2125            }
2126    
2127            /**
2128            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and userId = &#63;.
2129            *
2130            * <p>
2131            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2132            * </p>
2133            *
2134            * @param groupId the group ID
2135            * @param userId the user ID
2136            * @param start the lower bound of the range of journal articles
2137            * @param end the upper bound of the range of journal articles (not inclusive)
2138            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2139            * @return the ordered range of matching journal articles that the user has permission to view
2140            */
2141            public static List<JournalArticle> filterFindByG_U(long groupId,
2142                    long userId, int start, int end,
2143                    OrderByComparator<JournalArticle> orderByComparator) {
2144                    return getPersistence()
2145                                       .filterFindByG_U(groupId, userId, start, end,
2146                            orderByComparator);
2147            }
2148    
2149            /**
2150            * 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;.
2151            *
2152            * @param id the primary key of the current journal article
2153            * @param groupId the group ID
2154            * @param userId the user ID
2155            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2156            * @return the previous, current, and next journal article
2157            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2158            */
2159            public static JournalArticle[] filterFindByG_U_PrevAndNext(long id,
2160                    long groupId, long userId,
2161                    OrderByComparator<JournalArticle> orderByComparator)
2162                    throws com.liferay.portlet.journal.NoSuchArticleException {
2163                    return getPersistence()
2164                                       .filterFindByG_U_PrevAndNext(id, groupId, userId,
2165                            orderByComparator);
2166            }
2167    
2168            /**
2169            * Removes all the journal articles where groupId = &#63; and userId = &#63; from the database.
2170            *
2171            * @param groupId the group ID
2172            * @param userId the user ID
2173            */
2174            public static void removeByG_U(long groupId, long userId) {
2175                    getPersistence().removeByG_U(groupId, userId);
2176            }
2177    
2178            /**
2179            * Returns the number of journal articles where groupId = &#63; and userId = &#63;.
2180            *
2181            * @param groupId the group ID
2182            * @param userId the user ID
2183            * @return the number of matching journal articles
2184            */
2185            public static int countByG_U(long groupId, long userId) {
2186                    return getPersistence().countByG_U(groupId, userId);
2187            }
2188    
2189            /**
2190            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63;.
2191            *
2192            * @param groupId the group ID
2193            * @param userId the user ID
2194            * @return the number of matching journal articles that the user has permission to view
2195            */
2196            public static int filterCountByG_U(long groupId, long userId) {
2197                    return getPersistence().filterCountByG_U(groupId, userId);
2198            }
2199    
2200            /**
2201            * Returns all the journal articles where groupId = &#63; and folderId = &#63;.
2202            *
2203            * @param groupId the group ID
2204            * @param folderId the folder ID
2205            * @return the matching journal articles
2206            */
2207            public static List<JournalArticle> findByG_F(long groupId, long folderId) {
2208                    return getPersistence().findByG_F(groupId, folderId);
2209            }
2210    
2211            /**
2212            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63;.
2213            *
2214            * <p>
2215            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2216            * </p>
2217            *
2218            * @param groupId the group ID
2219            * @param folderId the folder ID
2220            * @param start the lower bound of the range of journal articles
2221            * @param end the upper bound of the range of journal articles (not inclusive)
2222            * @return the range of matching journal articles
2223            */
2224            public static List<JournalArticle> findByG_F(long groupId, long folderId,
2225                    int start, int end) {
2226                    return getPersistence().findByG_F(groupId, folderId, start, end);
2227            }
2228    
2229            /**
2230            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63;.
2231            *
2232            * <p>
2233            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2234            * </p>
2235            *
2236            * @param groupId the group ID
2237            * @param folderId the folder ID
2238            * @param start the lower bound of the range of journal articles
2239            * @param end the upper bound of the range of journal articles (not inclusive)
2240            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2241            * @return the ordered range of matching journal articles
2242            */
2243            public static List<JournalArticle> findByG_F(long groupId, long folderId,
2244                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
2245                    return getPersistence()
2246                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
2247            }
2248    
2249            /**
2250            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2251            *
2252            * @param groupId the group ID
2253            * @param folderId the folder ID
2254            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2255            * @return the first matching journal article
2256            * @throws NoSuchArticleException if a matching journal article could not be found
2257            */
2258            public static JournalArticle findByG_F_First(long groupId, long folderId,
2259                    OrderByComparator<JournalArticle> orderByComparator)
2260                    throws com.liferay.portlet.journal.NoSuchArticleException {
2261                    return getPersistence()
2262                                       .findByG_F_First(groupId, folderId, orderByComparator);
2263            }
2264    
2265            /**
2266            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2267            *
2268            * @param groupId the group ID
2269            * @param folderId the folder ID
2270            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2271            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2272            */
2273            public static JournalArticle fetchByG_F_First(long groupId, long folderId,
2274                    OrderByComparator<JournalArticle> orderByComparator) {
2275                    return getPersistence()
2276                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
2277            }
2278    
2279            /**
2280            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2281            *
2282            * @param groupId the group ID
2283            * @param folderId the folder ID
2284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2285            * @return the last matching journal article
2286            * @throws NoSuchArticleException if a matching journal article could not be found
2287            */
2288            public static JournalArticle findByG_F_Last(long groupId, long folderId,
2289                    OrderByComparator<JournalArticle> orderByComparator)
2290                    throws com.liferay.portlet.journal.NoSuchArticleException {
2291                    return getPersistence()
2292                                       .findByG_F_Last(groupId, folderId, orderByComparator);
2293            }
2294    
2295            /**
2296            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2297            *
2298            * @param groupId the group ID
2299            * @param folderId the folder ID
2300            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2301            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2302            */
2303            public static JournalArticle fetchByG_F_Last(long groupId, long folderId,
2304                    OrderByComparator<JournalArticle> orderByComparator) {
2305                    return getPersistence()
2306                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
2307            }
2308    
2309            /**
2310            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63;.
2311            *
2312            * @param id the primary key of the current journal article
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 previous, current, and next journal article
2317            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2318            */
2319            public static JournalArticle[] findByG_F_PrevAndNext(long id, long groupId,
2320                    long folderId, OrderByComparator<JournalArticle> orderByComparator)
2321                    throws com.liferay.portlet.journal.NoSuchArticleException {
2322                    return getPersistence()
2323                                       .findByG_F_PrevAndNext(id, groupId, folderId,
2324                            orderByComparator);
2325            }
2326    
2327            /**
2328            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2329            *
2330            * @param groupId the group ID
2331            * @param folderId the folder ID
2332            * @return the matching journal articles that the user has permission to view
2333            */
2334            public static List<JournalArticle> filterFindByG_F(long groupId,
2335                    long folderId) {
2336                    return getPersistence().filterFindByG_F(groupId, folderId);
2337            }
2338    
2339            /**
2340            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2341            *
2342            * <p>
2343            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2344            * </p>
2345            *
2346            * @param groupId the group ID
2347            * @param folderId the folder ID
2348            * @param start the lower bound of the range of journal articles
2349            * @param end the upper bound of the range of journal articles (not inclusive)
2350            * @return the range of matching journal articles that the user has permission to view
2351            */
2352            public static List<JournalArticle> filterFindByG_F(long groupId,
2353                    long folderId, int start, int end) {
2354                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
2355            }
2356    
2357            /**
2358            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and folderId = &#63;.
2359            *
2360            * <p>
2361            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2362            * </p>
2363            *
2364            * @param groupId the group ID
2365            * @param folderId the folder ID
2366            * @param start the lower bound of the range of journal articles
2367            * @param end the upper bound of the range of journal articles (not inclusive)
2368            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2369            * @return the ordered range of matching journal articles that the user has permission to view
2370            */
2371            public static List<JournalArticle> filterFindByG_F(long groupId,
2372                    long folderId, int start, int end,
2373                    OrderByComparator<JournalArticle> orderByComparator) {
2374                    return getPersistence()
2375                                       .filterFindByG_F(groupId, folderId, start, end,
2376                            orderByComparator);
2377            }
2378    
2379            /**
2380            * 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;.
2381            *
2382            * @param id the primary key of the current journal article
2383            * @param groupId the group ID
2384            * @param folderId the folder ID
2385            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2386            * @return the previous, current, and next journal article
2387            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2388            */
2389            public static JournalArticle[] filterFindByG_F_PrevAndNext(long id,
2390                    long groupId, long folderId,
2391                    OrderByComparator<JournalArticle> orderByComparator)
2392                    throws com.liferay.portlet.journal.NoSuchArticleException {
2393                    return getPersistence()
2394                                       .filterFindByG_F_PrevAndNext(id, groupId, folderId,
2395                            orderByComparator);
2396            }
2397    
2398            /**
2399            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2400            *
2401            * @param groupId the group ID
2402            * @param folderIds the folder IDs
2403            * @return the matching journal articles that the user has permission to view
2404            */
2405            public static List<JournalArticle> filterFindByG_F(long groupId,
2406                    long[] folderIds) {
2407                    return getPersistence().filterFindByG_F(groupId, folderIds);
2408            }
2409    
2410            /**
2411            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2412            *
2413            * <p>
2414            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2415            * </p>
2416            *
2417            * @param groupId the group ID
2418            * @param folderIds the folder IDs
2419            * @param start the lower bound of the range of journal articles
2420            * @param end the upper bound of the range of journal articles (not inclusive)
2421            * @return the range of matching journal articles that the user has permission to view
2422            */
2423            public static List<JournalArticle> filterFindByG_F(long groupId,
2424                    long[] folderIds, int start, int end) {
2425                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
2426            }
2427    
2428            /**
2429            * Returns an ordered range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2430            *
2431            * <p>
2432            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2433            * </p>
2434            *
2435            * @param groupId the group ID
2436            * @param folderIds the folder IDs
2437            * @param start the lower bound of the range of journal articles
2438            * @param end the upper bound of the range of journal articles (not inclusive)
2439            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2440            * @return the ordered range of matching journal articles that the user has permission to view
2441            */
2442            public static List<JournalArticle> filterFindByG_F(long groupId,
2443                    long[] folderIds, int start, int end,
2444                    OrderByComparator<JournalArticle> orderByComparator) {
2445                    return getPersistence()
2446                                       .filterFindByG_F(groupId, folderIds, start, end,
2447                            orderByComparator);
2448            }
2449    
2450            /**
2451            * Returns all the journal articles where groupId = &#63; and folderId = any &#63;.
2452            *
2453            * <p>
2454            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2455            * </p>
2456            *
2457            * @param groupId the group ID
2458            * @param folderIds the folder IDs
2459            * @return the matching journal articles
2460            */
2461            public static List<JournalArticle> findByG_F(long groupId, long[] folderIds) {
2462                    return getPersistence().findByG_F(groupId, folderIds);
2463            }
2464    
2465            /**
2466            * Returns a range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2467            *
2468            * <p>
2469            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2470            * </p>
2471            *
2472            * @param groupId the group ID
2473            * @param folderIds the folder IDs
2474            * @param start the lower bound of the range of journal articles
2475            * @param end the upper bound of the range of journal articles (not inclusive)
2476            * @return the range of matching journal articles
2477            */
2478            public static List<JournalArticle> findByG_F(long groupId,
2479                    long[] folderIds, int start, int end) {
2480                    return getPersistence().findByG_F(groupId, folderIds, start, end);
2481            }
2482    
2483            /**
2484            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = any &#63;.
2485            *
2486            * <p>
2487            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2488            * </p>
2489            *
2490            * @param groupId the group ID
2491            * @param folderIds the folder IDs
2492            * @param start the lower bound of the range of journal articles
2493            * @param end the upper bound of the range of journal articles (not inclusive)
2494            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2495            * @return the ordered range of matching journal articles
2496            */
2497            public static List<JournalArticle> findByG_F(long groupId,
2498                    long[] folderIds, int start, int end,
2499                    OrderByComparator<JournalArticle> orderByComparator) {
2500                    return getPersistence()
2501                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
2502            }
2503    
2504            /**
2505            * Removes all the journal articles where groupId = &#63; and folderId = &#63; from the database.
2506            *
2507            * @param groupId the group ID
2508            * @param folderId the folder ID
2509            */
2510            public static void removeByG_F(long groupId, long folderId) {
2511                    getPersistence().removeByG_F(groupId, folderId);
2512            }
2513    
2514            /**
2515            * Returns the number of journal articles where groupId = &#63; and folderId = &#63;.
2516            *
2517            * @param groupId the group ID
2518            * @param folderId the folder ID
2519            * @return the number of matching journal articles
2520            */
2521            public static int countByG_F(long groupId, long folderId) {
2522                    return getPersistence().countByG_F(groupId, folderId);
2523            }
2524    
2525            /**
2526            * Returns the number of journal articles where groupId = &#63; and folderId = any &#63;.
2527            *
2528            * @param groupId the group ID
2529            * @param folderIds the folder IDs
2530            * @return the number of matching journal articles
2531            */
2532            public static int countByG_F(long groupId, long[] folderIds) {
2533                    return getPersistence().countByG_F(groupId, folderIds);
2534            }
2535    
2536            /**
2537            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63;.
2538            *
2539            * @param groupId the group ID
2540            * @param folderId the folder ID
2541            * @return the number of matching journal articles that the user has permission to view
2542            */
2543            public static int filterCountByG_F(long groupId, long folderId) {
2544                    return getPersistence().filterCountByG_F(groupId, folderId);
2545            }
2546    
2547            /**
2548            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = any &#63;.
2549            *
2550            * @param groupId the group ID
2551            * @param folderIds the folder IDs
2552            * @return the number of matching journal articles that the user has permission to view
2553            */
2554            public static int filterCountByG_F(long groupId, long[] folderIds) {
2555                    return getPersistence().filterCountByG_F(groupId, folderIds);
2556            }
2557    
2558            /**
2559            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
2560            *
2561            * @param groupId the group ID
2562            * @param articleId the article ID
2563            * @return the matching journal articles
2564            */
2565            public static List<JournalArticle> findByG_A(long groupId,
2566                    java.lang.String articleId) {
2567                    return getPersistence().findByG_A(groupId, articleId);
2568            }
2569    
2570            /**
2571            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
2572            *
2573            * <p>
2574            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2575            * </p>
2576            *
2577            * @param groupId the group ID
2578            * @param articleId the article ID
2579            * @param start the lower bound of the range of journal articles
2580            * @param end the upper bound of the range of journal articles (not inclusive)
2581            * @return the range of matching journal articles
2582            */
2583            public static List<JournalArticle> findByG_A(long groupId,
2584                    java.lang.String articleId, int start, int end) {
2585                    return getPersistence().findByG_A(groupId, articleId, start, end);
2586            }
2587    
2588            /**
2589            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
2590            *
2591            * <p>
2592            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2593            * </p>
2594            *
2595            * @param groupId the group ID
2596            * @param articleId the article ID
2597            * @param start the lower bound of the range of journal articles
2598            * @param end the upper bound of the range of journal articles (not inclusive)
2599            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2600            * @return the ordered range of matching journal articles
2601            */
2602            public static List<JournalArticle> findByG_A(long groupId,
2603                    java.lang.String articleId, int start, int end,
2604                    OrderByComparator<JournalArticle> orderByComparator) {
2605                    return getPersistence()
2606                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
2607            }
2608    
2609            /**
2610            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2611            *
2612            * @param groupId the group ID
2613            * @param articleId the article ID
2614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2615            * @return the first matching journal article
2616            * @throws NoSuchArticleException if a matching journal article could not be found
2617            */
2618            public static JournalArticle findByG_A_First(long groupId,
2619                    java.lang.String articleId,
2620                    OrderByComparator<JournalArticle> orderByComparator)
2621                    throws com.liferay.portlet.journal.NoSuchArticleException {
2622                    return getPersistence()
2623                                       .findByG_A_First(groupId, articleId, orderByComparator);
2624            }
2625    
2626            /**
2627            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2628            *
2629            * @param groupId the group ID
2630            * @param articleId the article ID
2631            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2632            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2633            */
2634            public static JournalArticle fetchByG_A_First(long groupId,
2635                    java.lang.String articleId,
2636                    OrderByComparator<JournalArticle> orderByComparator) {
2637                    return getPersistence()
2638                                       .fetchByG_A_First(groupId, articleId, orderByComparator);
2639            }
2640    
2641            /**
2642            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2643            *
2644            * @param groupId the group ID
2645            * @param articleId the article ID
2646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2647            * @return the last matching journal article
2648            * @throws NoSuchArticleException if a matching journal article could not be found
2649            */
2650            public static JournalArticle findByG_A_Last(long groupId,
2651                    java.lang.String articleId,
2652                    OrderByComparator<JournalArticle> orderByComparator)
2653                    throws com.liferay.portlet.journal.NoSuchArticleException {
2654                    return getPersistence()
2655                                       .findByG_A_Last(groupId, articleId, orderByComparator);
2656            }
2657    
2658            /**
2659            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2660            *
2661            * @param groupId the group ID
2662            * @param articleId the article ID
2663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2664            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2665            */
2666            public static JournalArticle fetchByG_A_Last(long groupId,
2667                    java.lang.String articleId,
2668                    OrderByComparator<JournalArticle> orderByComparator) {
2669                    return getPersistence()
2670                                       .fetchByG_A_Last(groupId, articleId, orderByComparator);
2671            }
2672    
2673            /**
2674            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
2675            *
2676            * @param id the primary key of the current journal article
2677            * @param groupId the group ID
2678            * @param articleId the article ID
2679            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2680            * @return the previous, current, and next journal article
2681            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2682            */
2683            public static JournalArticle[] findByG_A_PrevAndNext(long id, long groupId,
2684                    java.lang.String articleId,
2685                    OrderByComparator<JournalArticle> orderByComparator)
2686                    throws com.liferay.portlet.journal.NoSuchArticleException {
2687                    return getPersistence()
2688                                       .findByG_A_PrevAndNext(id, groupId, articleId,
2689                            orderByComparator);
2690            }
2691    
2692            /**
2693            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2694            *
2695            * @param groupId the group ID
2696            * @param articleId the article ID
2697            * @return the matching journal articles that the user has permission to view
2698            */
2699            public static List<JournalArticle> filterFindByG_A(long groupId,
2700                    java.lang.String articleId) {
2701                    return getPersistence().filterFindByG_A(groupId, articleId);
2702            }
2703    
2704            /**
2705            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2706            *
2707            * <p>
2708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2709            * </p>
2710            *
2711            * @param groupId the group ID
2712            * @param articleId the article ID
2713            * @param start the lower bound of the range of journal articles
2714            * @param end the upper bound of the range of journal articles (not inclusive)
2715            * @return the range of matching journal articles that the user has permission to view
2716            */
2717            public static List<JournalArticle> filterFindByG_A(long groupId,
2718                    java.lang.String articleId, int start, int end) {
2719                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
2720            }
2721    
2722            /**
2723            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
2724            *
2725            * <p>
2726            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2727            * </p>
2728            *
2729            * @param groupId the group ID
2730            * @param articleId the article ID
2731            * @param start the lower bound of the range of journal articles
2732            * @param end the upper bound of the range of journal articles (not inclusive)
2733            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2734            * @return the ordered range of matching journal articles that the user has permission to view
2735            */
2736            public static List<JournalArticle> filterFindByG_A(long groupId,
2737                    java.lang.String articleId, int start, int end,
2738                    OrderByComparator<JournalArticle> orderByComparator) {
2739                    return getPersistence()
2740                                       .filterFindByG_A(groupId, articleId, start, end,
2741                            orderByComparator);
2742            }
2743    
2744            /**
2745            * 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;.
2746            *
2747            * @param id the primary key of the current journal article
2748            * @param groupId the group ID
2749            * @param articleId the article ID
2750            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2751            * @return the previous, current, and next journal article
2752            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2753            */
2754            public static JournalArticle[] filterFindByG_A_PrevAndNext(long id,
2755                    long groupId, java.lang.String articleId,
2756                    OrderByComparator<JournalArticle> orderByComparator)
2757                    throws com.liferay.portlet.journal.NoSuchArticleException {
2758                    return getPersistence()
2759                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
2760                            orderByComparator);
2761            }
2762    
2763            /**
2764            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
2765            *
2766            * @param groupId the group ID
2767            * @param articleId the article ID
2768            */
2769            public static void removeByG_A(long groupId, java.lang.String articleId) {
2770                    getPersistence().removeByG_A(groupId, articleId);
2771            }
2772    
2773            /**
2774            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
2775            *
2776            * @param groupId the group ID
2777            * @param articleId the article ID
2778            * @return the number of matching journal articles
2779            */
2780            public static int countByG_A(long groupId, java.lang.String articleId) {
2781                    return getPersistence().countByG_A(groupId, articleId);
2782            }
2783    
2784            /**
2785            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
2786            *
2787            * @param groupId the group ID
2788            * @param articleId the article ID
2789            * @return the number of matching journal articles that the user has permission to view
2790            */
2791            public static int filterCountByG_A(long groupId, java.lang.String articleId) {
2792                    return getPersistence().filterCountByG_A(groupId, articleId);
2793            }
2794    
2795            /**
2796            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
2797            *
2798            * @param groupId the group ID
2799            * @param urlTitle the url title
2800            * @return the matching journal articles
2801            */
2802            public static List<JournalArticle> findByG_UT(long groupId,
2803                    java.lang.String urlTitle) {
2804                    return getPersistence().findByG_UT(groupId, urlTitle);
2805            }
2806    
2807            /**
2808            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2809            *
2810            * <p>
2811            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2812            * </p>
2813            *
2814            * @param groupId the group ID
2815            * @param urlTitle the url title
2816            * @param start the lower bound of the range of journal articles
2817            * @param end the upper bound of the range of journal articles (not inclusive)
2818            * @return the range of matching journal articles
2819            */
2820            public static List<JournalArticle> findByG_UT(long groupId,
2821                    java.lang.String urlTitle, int start, int end) {
2822                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
2823            }
2824    
2825            /**
2826            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
2827            *
2828            * <p>
2829            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2830            * </p>
2831            *
2832            * @param groupId the group ID
2833            * @param urlTitle the url title
2834            * @param start the lower bound of the range of journal articles
2835            * @param end the upper bound of the range of journal articles (not inclusive)
2836            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2837            * @return the ordered range of matching journal articles
2838            */
2839            public static List<JournalArticle> findByG_UT(long groupId,
2840                    java.lang.String urlTitle, int start, int end,
2841                    OrderByComparator<JournalArticle> orderByComparator) {
2842                    return getPersistence()
2843                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
2844            }
2845    
2846            /**
2847            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2848            *
2849            * @param groupId the group ID
2850            * @param urlTitle the url title
2851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2852            * @return the first matching journal article
2853            * @throws NoSuchArticleException if a matching journal article could not be found
2854            */
2855            public static JournalArticle findByG_UT_First(long groupId,
2856                    java.lang.String urlTitle,
2857                    OrderByComparator<JournalArticle> orderByComparator)
2858                    throws com.liferay.portlet.journal.NoSuchArticleException {
2859                    return getPersistence()
2860                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
2861            }
2862    
2863            /**
2864            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2865            *
2866            * @param groupId the group ID
2867            * @param urlTitle the url title
2868            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2869            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
2870            */
2871            public static JournalArticle fetchByG_UT_First(long groupId,
2872                    java.lang.String urlTitle,
2873                    OrderByComparator<JournalArticle> orderByComparator) {
2874                    return getPersistence()
2875                                       .fetchByG_UT_First(groupId, urlTitle, orderByComparator);
2876            }
2877    
2878            /**
2879            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2880            *
2881            * @param groupId the group ID
2882            * @param urlTitle the url title
2883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2884            * @return the last matching journal article
2885            * @throws NoSuchArticleException if a matching journal article could not be found
2886            */
2887            public static JournalArticle findByG_UT_Last(long groupId,
2888                    java.lang.String urlTitle,
2889                    OrderByComparator<JournalArticle> orderByComparator)
2890                    throws com.liferay.portlet.journal.NoSuchArticleException {
2891                    return getPersistence()
2892                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
2893            }
2894    
2895            /**
2896            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2897            *
2898            * @param groupId the group ID
2899            * @param urlTitle the url title
2900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2901            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
2902            */
2903            public static JournalArticle fetchByG_UT_Last(long groupId,
2904                    java.lang.String urlTitle,
2905                    OrderByComparator<JournalArticle> orderByComparator) {
2906                    return getPersistence()
2907                                       .fetchByG_UT_Last(groupId, urlTitle, orderByComparator);
2908            }
2909    
2910            /**
2911            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
2912            *
2913            * @param id the primary key of the current journal article
2914            * @param groupId the group ID
2915            * @param urlTitle the url title
2916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2917            * @return the previous, current, and next journal article
2918            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2919            */
2920            public static JournalArticle[] findByG_UT_PrevAndNext(long id,
2921                    long groupId, java.lang.String urlTitle,
2922                    OrderByComparator<JournalArticle> orderByComparator)
2923                    throws com.liferay.portlet.journal.NoSuchArticleException {
2924                    return getPersistence()
2925                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
2926                            orderByComparator);
2927            }
2928    
2929            /**
2930            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2931            *
2932            * @param groupId the group ID
2933            * @param urlTitle the url title
2934            * @return the matching journal articles that the user has permission to view
2935            */
2936            public static List<JournalArticle> filterFindByG_UT(long groupId,
2937                    java.lang.String urlTitle) {
2938                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
2939            }
2940    
2941            /**
2942            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
2943            *
2944            * <p>
2945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2946            * </p>
2947            *
2948            * @param groupId the group ID
2949            * @param urlTitle the url title
2950            * @param start the lower bound of the range of journal articles
2951            * @param end the upper bound of the range of journal articles (not inclusive)
2952            * @return the range of matching journal articles that the user has permission to view
2953            */
2954            public static List<JournalArticle> filterFindByG_UT(long groupId,
2955                    java.lang.String urlTitle, int start, int end) {
2956                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
2957            }
2958    
2959            /**
2960            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
2961            *
2962            * <p>
2963            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2964            * </p>
2965            *
2966            * @param groupId the group ID
2967            * @param urlTitle the url title
2968            * @param start the lower bound of the range of journal articles
2969            * @param end the upper bound of the range of journal articles (not inclusive)
2970            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2971            * @return the ordered range of matching journal articles that the user has permission to view
2972            */
2973            public static List<JournalArticle> filterFindByG_UT(long groupId,
2974                    java.lang.String urlTitle, int start, int end,
2975                    OrderByComparator<JournalArticle> orderByComparator) {
2976                    return getPersistence()
2977                                       .filterFindByG_UT(groupId, urlTitle, start, end,
2978                            orderByComparator);
2979            }
2980    
2981            /**
2982            * 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;.
2983            *
2984            * @param id the primary key of the current journal article
2985            * @param groupId the group ID
2986            * @param urlTitle the url title
2987            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2988            * @return the previous, current, and next journal article
2989            * @throws NoSuchArticleException if a journal article with the primary key could not be found
2990            */
2991            public static JournalArticle[] filterFindByG_UT_PrevAndNext(long id,
2992                    long groupId, java.lang.String urlTitle,
2993                    OrderByComparator<JournalArticle> orderByComparator)
2994                    throws com.liferay.portlet.journal.NoSuchArticleException {
2995                    return getPersistence()
2996                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
2997                            orderByComparator);
2998            }
2999    
3000            /**
3001            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
3002            *
3003            * @param groupId the group ID
3004            * @param urlTitle the url title
3005            */
3006            public static void removeByG_UT(long groupId, java.lang.String urlTitle) {
3007                    getPersistence().removeByG_UT(groupId, urlTitle);
3008            }
3009    
3010            /**
3011            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
3012            *
3013            * @param groupId the group ID
3014            * @param urlTitle the url title
3015            * @return the number of matching journal articles
3016            */
3017            public static int countByG_UT(long groupId, java.lang.String urlTitle) {
3018                    return getPersistence().countByG_UT(groupId, urlTitle);
3019            }
3020    
3021            /**
3022            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
3023            *
3024            * @param groupId the group ID
3025            * @param urlTitle the url title
3026            * @return the number of matching journal articles that the user has permission to view
3027            */
3028            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) {
3029                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
3030            }
3031    
3032            /**
3033            * Returns all the journal articles where groupId = &#63; and DDMStructureKey = &#63;.
3034            *
3035            * @param groupId the group ID
3036            * @param DDMStructureKey the d d m structure key
3037            * @return the matching journal articles
3038            */
3039            public static List<JournalArticle> findByG_DDMSK(long groupId,
3040                    java.lang.String DDMStructureKey) {
3041                    return getPersistence().findByG_DDMSK(groupId, DDMStructureKey);
3042            }
3043    
3044            /**
3045            * Returns a range of all the journal articles where groupId = &#63; and DDMStructureKey = &#63;.
3046            *
3047            * <p>
3048            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3049            * </p>
3050            *
3051            * @param groupId the group ID
3052            * @param DDMStructureKey the d d m structure key
3053            * @param start the lower bound of the range of journal articles
3054            * @param end the upper bound of the range of journal articles (not inclusive)
3055            * @return the range of matching journal articles
3056            */
3057            public static List<JournalArticle> findByG_DDMSK(long groupId,
3058                    java.lang.String DDMStructureKey, int start, int end) {
3059                    return getPersistence()
3060                                       .findByG_DDMSK(groupId, DDMStructureKey, start, end);
3061            }
3062    
3063            /**
3064            * Returns an ordered range of all the journal articles where groupId = &#63; and DDMStructureKey = &#63;.
3065            *
3066            * <p>
3067            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3068            * </p>
3069            *
3070            * @param groupId the group ID
3071            * @param DDMStructureKey the d d m structure key
3072            * @param start the lower bound of the range of journal articles
3073            * @param end the upper bound of the range of journal articles (not inclusive)
3074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3075            * @return the ordered range of matching journal articles
3076            */
3077            public static List<JournalArticle> findByG_DDMSK(long groupId,
3078                    java.lang.String DDMStructureKey, int start, int end,
3079                    OrderByComparator<JournalArticle> orderByComparator) {
3080                    return getPersistence()
3081                                       .findByG_DDMSK(groupId, DDMStructureKey, start, end,
3082                            orderByComparator);
3083            }
3084    
3085            /**
3086            * Returns the first journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
3087            *
3088            * @param groupId the group ID
3089            * @param DDMStructureKey the d d m structure key
3090            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3091            * @return the first matching journal article
3092            * @throws NoSuchArticleException if a matching journal article could not be found
3093            */
3094            public static JournalArticle findByG_DDMSK_First(long groupId,
3095                    java.lang.String DDMStructureKey,
3096                    OrderByComparator<JournalArticle> orderByComparator)
3097                    throws com.liferay.portlet.journal.NoSuchArticleException {
3098                    return getPersistence()
3099                                       .findByG_DDMSK_First(groupId, DDMStructureKey,
3100                            orderByComparator);
3101            }
3102    
3103            /**
3104            * Returns the first journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
3105            *
3106            * @param groupId the group ID
3107            * @param DDMStructureKey the d d m structure key
3108            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3109            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3110            */
3111            public static JournalArticle fetchByG_DDMSK_First(long groupId,
3112                    java.lang.String DDMStructureKey,
3113                    OrderByComparator<JournalArticle> orderByComparator) {
3114                    return getPersistence()
3115                                       .fetchByG_DDMSK_First(groupId, DDMStructureKey,
3116                            orderByComparator);
3117            }
3118    
3119            /**
3120            * Returns the last journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
3121            *
3122            * @param groupId the group ID
3123            * @param DDMStructureKey the d d m structure key
3124            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3125            * @return the last matching journal article
3126            * @throws NoSuchArticleException if a matching journal article could not be found
3127            */
3128            public static JournalArticle findByG_DDMSK_Last(long groupId,
3129                    java.lang.String DDMStructureKey,
3130                    OrderByComparator<JournalArticle> orderByComparator)
3131                    throws com.liferay.portlet.journal.NoSuchArticleException {
3132                    return getPersistence()
3133                                       .findByG_DDMSK_Last(groupId, DDMStructureKey,
3134                            orderByComparator);
3135            }
3136    
3137            /**
3138            * Returns the last journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
3139            *
3140            * @param groupId the group ID
3141            * @param DDMStructureKey the d d m structure key
3142            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3143            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3144            */
3145            public static JournalArticle fetchByG_DDMSK_Last(long groupId,
3146                    java.lang.String DDMStructureKey,
3147                    OrderByComparator<JournalArticle> orderByComparator) {
3148                    return getPersistence()
3149                                       .fetchByG_DDMSK_Last(groupId, DDMStructureKey,
3150                            orderByComparator);
3151            }
3152    
3153            /**
3154            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and DDMStructureKey = &#63;.
3155            *
3156            * @param id the primary key of the current journal article
3157            * @param groupId the group ID
3158            * @param DDMStructureKey the d d m structure key
3159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3160            * @return the previous, current, and next journal article
3161            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3162            */
3163            public static JournalArticle[] findByG_DDMSK_PrevAndNext(long id,
3164                    long groupId, java.lang.String DDMStructureKey,
3165                    OrderByComparator<JournalArticle> orderByComparator)
3166                    throws com.liferay.portlet.journal.NoSuchArticleException {
3167                    return getPersistence()
3168                                       .findByG_DDMSK_PrevAndNext(id, groupId, DDMStructureKey,
3169                            orderByComparator);
3170            }
3171    
3172            /**
3173            * Returns all the journal articles that the user has permission to view where groupId = &#63; and DDMStructureKey = &#63;.
3174            *
3175            * @param groupId the group ID
3176            * @param DDMStructureKey the d d m structure key
3177            * @return the matching journal articles that the user has permission to view
3178            */
3179            public static List<JournalArticle> filterFindByG_DDMSK(long groupId,
3180                    java.lang.String DDMStructureKey) {
3181                    return getPersistence().filterFindByG_DDMSK(groupId, DDMStructureKey);
3182            }
3183    
3184            /**
3185            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and DDMStructureKey = &#63;.
3186            *
3187            * <p>
3188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3189            * </p>
3190            *
3191            * @param groupId the group ID
3192            * @param DDMStructureKey the d d m structure key
3193            * @param start the lower bound of the range of journal articles
3194            * @param end the upper bound of the range of journal articles (not inclusive)
3195            * @return the range of matching journal articles that the user has permission to view
3196            */
3197            public static List<JournalArticle> filterFindByG_DDMSK(long groupId,
3198                    java.lang.String DDMStructureKey, int start, int end) {
3199                    return getPersistence()
3200                                       .filterFindByG_DDMSK(groupId, DDMStructureKey, start, end);
3201            }
3202    
3203            /**
3204            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and DDMStructureKey = &#63;.
3205            *
3206            * <p>
3207            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3208            * </p>
3209            *
3210            * @param groupId the group ID
3211            * @param DDMStructureKey the d d m structure key
3212            * @param start the lower bound of the range of journal articles
3213            * @param end the upper bound of the range of journal articles (not inclusive)
3214            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3215            * @return the ordered range of matching journal articles that the user has permission to view
3216            */
3217            public static List<JournalArticle> filterFindByG_DDMSK(long groupId,
3218                    java.lang.String DDMStructureKey, int start, int end,
3219                    OrderByComparator<JournalArticle> orderByComparator) {
3220                    return getPersistence()
3221                                       .filterFindByG_DDMSK(groupId, DDMStructureKey, start, end,
3222                            orderByComparator);
3223            }
3224    
3225            /**
3226            * 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 DDMStructureKey = &#63;.
3227            *
3228            * @param id the primary key of the current journal article
3229            * @param groupId the group ID
3230            * @param DDMStructureKey the d d m structure key
3231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3232            * @return the previous, current, and next journal article
3233            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3234            */
3235            public static JournalArticle[] filterFindByG_DDMSK_PrevAndNext(long id,
3236                    long groupId, java.lang.String DDMStructureKey,
3237                    OrderByComparator<JournalArticle> orderByComparator)
3238                    throws com.liferay.portlet.journal.NoSuchArticleException {
3239                    return getPersistence()
3240                                       .filterFindByG_DDMSK_PrevAndNext(id, groupId,
3241                            DDMStructureKey, orderByComparator);
3242            }
3243    
3244            /**
3245            * Removes all the journal articles where groupId = &#63; and DDMStructureKey = &#63; from the database.
3246            *
3247            * @param groupId the group ID
3248            * @param DDMStructureKey the d d m structure key
3249            */
3250            public static void removeByG_DDMSK(long groupId,
3251                    java.lang.String DDMStructureKey) {
3252                    getPersistence().removeByG_DDMSK(groupId, DDMStructureKey);
3253            }
3254    
3255            /**
3256            * Returns the number of journal articles where groupId = &#63; and DDMStructureKey = &#63;.
3257            *
3258            * @param groupId the group ID
3259            * @param DDMStructureKey the d d m structure key
3260            * @return the number of matching journal articles
3261            */
3262            public static int countByG_DDMSK(long groupId,
3263                    java.lang.String DDMStructureKey) {
3264                    return getPersistence().countByG_DDMSK(groupId, DDMStructureKey);
3265            }
3266    
3267            /**
3268            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and DDMStructureKey = &#63;.
3269            *
3270            * @param groupId the group ID
3271            * @param DDMStructureKey the d d m structure key
3272            * @return the number of matching journal articles that the user has permission to view
3273            */
3274            public static int filterCountByG_DDMSK(long groupId,
3275                    java.lang.String DDMStructureKey) {
3276                    return getPersistence().filterCountByG_DDMSK(groupId, DDMStructureKey);
3277            }
3278    
3279            /**
3280            * Returns all the journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
3281            *
3282            * @param groupId the group ID
3283            * @param DDMTemplateKey the d d m template key
3284            * @return the matching journal articles
3285            */
3286            public static List<JournalArticle> findByG_DDMTK(long groupId,
3287                    java.lang.String DDMTemplateKey) {
3288                    return getPersistence().findByG_DDMTK(groupId, DDMTemplateKey);
3289            }
3290    
3291            /**
3292            * Returns a range of all the journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
3293            *
3294            * <p>
3295            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3296            * </p>
3297            *
3298            * @param groupId the group ID
3299            * @param DDMTemplateKey the d d m template key
3300            * @param start the lower bound of the range of journal articles
3301            * @param end the upper bound of the range of journal articles (not inclusive)
3302            * @return the range of matching journal articles
3303            */
3304            public static List<JournalArticle> findByG_DDMTK(long groupId,
3305                    java.lang.String DDMTemplateKey, int start, int end) {
3306                    return getPersistence()
3307                                       .findByG_DDMTK(groupId, DDMTemplateKey, start, end);
3308            }
3309    
3310            /**
3311            * Returns an ordered range of all the journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
3312            *
3313            * <p>
3314            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3315            * </p>
3316            *
3317            * @param groupId the group ID
3318            * @param DDMTemplateKey the d d m template key
3319            * @param start the lower bound of the range of journal articles
3320            * @param end the upper bound of the range of journal articles (not inclusive)
3321            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3322            * @return the ordered range of matching journal articles
3323            */
3324            public static List<JournalArticle> findByG_DDMTK(long groupId,
3325                    java.lang.String DDMTemplateKey, int start, int end,
3326                    OrderByComparator<JournalArticle> orderByComparator) {
3327                    return getPersistence()
3328                                       .findByG_DDMTK(groupId, DDMTemplateKey, start, end,
3329                            orderByComparator);
3330            }
3331    
3332            /**
3333            * Returns the first journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
3334            *
3335            * @param groupId the group ID
3336            * @param DDMTemplateKey the d d m template key
3337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3338            * @return the first matching journal article
3339            * @throws NoSuchArticleException if a matching journal article could not be found
3340            */
3341            public static JournalArticle findByG_DDMTK_First(long groupId,
3342                    java.lang.String DDMTemplateKey,
3343                    OrderByComparator<JournalArticle> orderByComparator)
3344                    throws com.liferay.portlet.journal.NoSuchArticleException {
3345                    return getPersistence()
3346                                       .findByG_DDMTK_First(groupId, DDMTemplateKey,
3347                            orderByComparator);
3348            }
3349    
3350            /**
3351            * Returns the first journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
3352            *
3353            * @param groupId the group ID
3354            * @param DDMTemplateKey the d d m template key
3355            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3356            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3357            */
3358            public static JournalArticle fetchByG_DDMTK_First(long groupId,
3359                    java.lang.String DDMTemplateKey,
3360                    OrderByComparator<JournalArticle> orderByComparator) {
3361                    return getPersistence()
3362                                       .fetchByG_DDMTK_First(groupId, DDMTemplateKey,
3363                            orderByComparator);
3364            }
3365    
3366            /**
3367            * Returns the last journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
3368            *
3369            * @param groupId the group ID
3370            * @param DDMTemplateKey the d d m template key
3371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3372            * @return the last matching journal article
3373            * @throws NoSuchArticleException if a matching journal article could not be found
3374            */
3375            public static JournalArticle findByG_DDMTK_Last(long groupId,
3376                    java.lang.String DDMTemplateKey,
3377                    OrderByComparator<JournalArticle> orderByComparator)
3378                    throws com.liferay.portlet.journal.NoSuchArticleException {
3379                    return getPersistence()
3380                                       .findByG_DDMTK_Last(groupId, DDMTemplateKey,
3381                            orderByComparator);
3382            }
3383    
3384            /**
3385            * Returns the last journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
3386            *
3387            * @param groupId the group ID
3388            * @param DDMTemplateKey the d d m template key
3389            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3390            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3391            */
3392            public static JournalArticle fetchByG_DDMTK_Last(long groupId,
3393                    java.lang.String DDMTemplateKey,
3394                    OrderByComparator<JournalArticle> orderByComparator) {
3395                    return getPersistence()
3396                                       .fetchByG_DDMTK_Last(groupId, DDMTemplateKey,
3397                            orderByComparator);
3398            }
3399    
3400            /**
3401            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and DDMTemplateKey = &#63;.
3402            *
3403            * @param id the primary key of the current journal article
3404            * @param groupId the group ID
3405            * @param DDMTemplateKey the d d m template key
3406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3407            * @return the previous, current, and next journal article
3408            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3409            */
3410            public static JournalArticle[] findByG_DDMTK_PrevAndNext(long id,
3411                    long groupId, java.lang.String DDMTemplateKey,
3412                    OrderByComparator<JournalArticle> orderByComparator)
3413                    throws com.liferay.portlet.journal.NoSuchArticleException {
3414                    return getPersistence()
3415                                       .findByG_DDMTK_PrevAndNext(id, groupId, DDMTemplateKey,
3416                            orderByComparator);
3417            }
3418    
3419            /**
3420            * Returns all the journal articles that the user has permission to view where groupId = &#63; and DDMTemplateKey = &#63;.
3421            *
3422            * @param groupId the group ID
3423            * @param DDMTemplateKey the d d m template key
3424            * @return the matching journal articles that the user has permission to view
3425            */
3426            public static List<JournalArticle> filterFindByG_DDMTK(long groupId,
3427                    java.lang.String DDMTemplateKey) {
3428                    return getPersistence().filterFindByG_DDMTK(groupId, DDMTemplateKey);
3429            }
3430    
3431            /**
3432            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and DDMTemplateKey = &#63;.
3433            *
3434            * <p>
3435            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3436            * </p>
3437            *
3438            * @param groupId the group ID
3439            * @param DDMTemplateKey the d d m template key
3440            * @param start the lower bound of the range of journal articles
3441            * @param end the upper bound of the range of journal articles (not inclusive)
3442            * @return the range of matching journal articles that the user has permission to view
3443            */
3444            public static List<JournalArticle> filterFindByG_DDMTK(long groupId,
3445                    java.lang.String DDMTemplateKey, int start, int end) {
3446                    return getPersistence()
3447                                       .filterFindByG_DDMTK(groupId, DDMTemplateKey, start, end);
3448            }
3449    
3450            /**
3451            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and DDMTemplateKey = &#63;.
3452            *
3453            * <p>
3454            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3455            * </p>
3456            *
3457            * @param groupId the group ID
3458            * @param DDMTemplateKey the d d m template key
3459            * @param start the lower bound of the range of journal articles
3460            * @param end the upper bound of the range of journal articles (not inclusive)
3461            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3462            * @return the ordered range of matching journal articles that the user has permission to view
3463            */
3464            public static List<JournalArticle> filterFindByG_DDMTK(long groupId,
3465                    java.lang.String DDMTemplateKey, int start, int end,
3466                    OrderByComparator<JournalArticle> orderByComparator) {
3467                    return getPersistence()
3468                                       .filterFindByG_DDMTK(groupId, DDMTemplateKey, start, end,
3469                            orderByComparator);
3470            }
3471    
3472            /**
3473            * 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 DDMTemplateKey = &#63;.
3474            *
3475            * @param id the primary key of the current journal article
3476            * @param groupId the group ID
3477            * @param DDMTemplateKey the d d m template key
3478            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3479            * @return the previous, current, and next journal article
3480            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3481            */
3482            public static JournalArticle[] filterFindByG_DDMTK_PrevAndNext(long id,
3483                    long groupId, java.lang.String DDMTemplateKey,
3484                    OrderByComparator<JournalArticle> orderByComparator)
3485                    throws com.liferay.portlet.journal.NoSuchArticleException {
3486                    return getPersistence()
3487                                       .filterFindByG_DDMTK_PrevAndNext(id, groupId,
3488                            DDMTemplateKey, orderByComparator);
3489            }
3490    
3491            /**
3492            * Removes all the journal articles where groupId = &#63; and DDMTemplateKey = &#63; from the database.
3493            *
3494            * @param groupId the group ID
3495            * @param DDMTemplateKey the d d m template key
3496            */
3497            public static void removeByG_DDMTK(long groupId,
3498                    java.lang.String DDMTemplateKey) {
3499                    getPersistence().removeByG_DDMTK(groupId, DDMTemplateKey);
3500            }
3501    
3502            /**
3503            * Returns the number of journal articles where groupId = &#63; and DDMTemplateKey = &#63;.
3504            *
3505            * @param groupId the group ID
3506            * @param DDMTemplateKey the d d m template key
3507            * @return the number of matching journal articles
3508            */
3509            public static int countByG_DDMTK(long groupId,
3510                    java.lang.String DDMTemplateKey) {
3511                    return getPersistence().countByG_DDMTK(groupId, DDMTemplateKey);
3512            }
3513    
3514            /**
3515            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and DDMTemplateKey = &#63;.
3516            *
3517            * @param groupId the group ID
3518            * @param DDMTemplateKey the d d m template key
3519            * @return the number of matching journal articles that the user has permission to view
3520            */
3521            public static int filterCountByG_DDMTK(long groupId,
3522                    java.lang.String DDMTemplateKey) {
3523                    return getPersistence().filterCountByG_DDMTK(groupId, DDMTemplateKey);
3524            }
3525    
3526            /**
3527            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3528            *
3529            * @param groupId the group ID
3530            * @param layoutUuid the layout uuid
3531            * @return the matching journal articles
3532            */
3533            public static List<JournalArticle> findByG_L(long groupId,
3534                    java.lang.String layoutUuid) {
3535                    return getPersistence().findByG_L(groupId, layoutUuid);
3536            }
3537    
3538            /**
3539            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3540            *
3541            * <p>
3542            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3543            * </p>
3544            *
3545            * @param groupId the group ID
3546            * @param layoutUuid the layout uuid
3547            * @param start the lower bound of the range of journal articles
3548            * @param end the upper bound of the range of journal articles (not inclusive)
3549            * @return the range of matching journal articles
3550            */
3551            public static List<JournalArticle> findByG_L(long groupId,
3552                    java.lang.String layoutUuid, int start, int end) {
3553                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
3554            }
3555    
3556            /**
3557            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
3558            *
3559            * <p>
3560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3561            * </p>
3562            *
3563            * @param groupId the group ID
3564            * @param layoutUuid the layout uuid
3565            * @param start the lower bound of the range of journal articles
3566            * @param end the upper bound of the range of journal articles (not inclusive)
3567            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3568            * @return the ordered range of matching journal articles
3569            */
3570            public static List<JournalArticle> findByG_L(long groupId,
3571                    java.lang.String layoutUuid, int start, int end,
3572                    OrderByComparator<JournalArticle> orderByComparator) {
3573                    return getPersistence()
3574                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
3575            }
3576    
3577            /**
3578            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3579            *
3580            * @param groupId the group ID
3581            * @param layoutUuid the layout uuid
3582            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3583            * @return the first matching journal article
3584            * @throws NoSuchArticleException if a matching journal article could not be found
3585            */
3586            public static JournalArticle findByG_L_First(long groupId,
3587                    java.lang.String layoutUuid,
3588                    OrderByComparator<JournalArticle> orderByComparator)
3589                    throws com.liferay.portlet.journal.NoSuchArticleException {
3590                    return getPersistence()
3591                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
3592            }
3593    
3594            /**
3595            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3596            *
3597            * @param groupId the group ID
3598            * @param layoutUuid the layout uuid
3599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3600            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3601            */
3602            public static JournalArticle fetchByG_L_First(long groupId,
3603                    java.lang.String layoutUuid,
3604                    OrderByComparator<JournalArticle> orderByComparator) {
3605                    return getPersistence()
3606                                       .fetchByG_L_First(groupId, layoutUuid, orderByComparator);
3607            }
3608    
3609            /**
3610            * Returns the last 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 last matching journal article
3616            * @throws NoSuchArticleException if a matching journal article could not be found
3617            */
3618            public static JournalArticle findByG_L_Last(long groupId,
3619                    java.lang.String layoutUuid,
3620                    OrderByComparator<JournalArticle> orderByComparator)
3621                    throws com.liferay.portlet.journal.NoSuchArticleException {
3622                    return getPersistence()
3623                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
3624            }
3625    
3626            /**
3627            * Returns the last 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 last matching journal article, or <code>null</code> if a matching journal article could not be found
3633            */
3634            public static JournalArticle fetchByG_L_Last(long groupId,
3635                    java.lang.String layoutUuid,
3636                    OrderByComparator<JournalArticle> orderByComparator) {
3637                    return getPersistence()
3638                                       .fetchByG_L_Last(groupId, layoutUuid, orderByComparator);
3639            }
3640    
3641            /**
3642            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
3643            *
3644            * @param id the primary key of the current journal article
3645            * @param groupId the group ID
3646            * @param layoutUuid the layout uuid
3647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3648            * @return the previous, current, and next journal article
3649            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3650            */
3651            public static JournalArticle[] findByG_L_PrevAndNext(long id, long groupId,
3652                    java.lang.String layoutUuid,
3653                    OrderByComparator<JournalArticle> orderByComparator)
3654                    throws com.liferay.portlet.journal.NoSuchArticleException {
3655                    return getPersistence()
3656                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
3657                            orderByComparator);
3658            }
3659    
3660            /**
3661            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3662            *
3663            * @param groupId the group ID
3664            * @param layoutUuid the layout uuid
3665            * @return the matching journal articles that the user has permission to view
3666            */
3667            public static List<JournalArticle> filterFindByG_L(long groupId,
3668                    java.lang.String layoutUuid) {
3669                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
3670            }
3671    
3672            /**
3673            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3674            *
3675            * <p>
3676            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3677            * </p>
3678            *
3679            * @param groupId the group ID
3680            * @param layoutUuid the layout uuid
3681            * @param start the lower bound of the range of journal articles
3682            * @param end the upper bound of the range of journal articles (not inclusive)
3683            * @return the range of matching journal articles that the user has permission to view
3684            */
3685            public static List<JournalArticle> filterFindByG_L(long groupId,
3686                    java.lang.String layoutUuid, int start, int end) {
3687                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
3688            }
3689    
3690            /**
3691            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
3692            *
3693            * <p>
3694            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3695            * </p>
3696            *
3697            * @param groupId the group ID
3698            * @param layoutUuid the layout uuid
3699            * @param start the lower bound of the range of journal articles
3700            * @param end the upper bound of the range of journal articles (not inclusive)
3701            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3702            * @return the ordered range of matching journal articles that the user has permission to view
3703            */
3704            public static List<JournalArticle> filterFindByG_L(long groupId,
3705                    java.lang.String layoutUuid, int start, int end,
3706                    OrderByComparator<JournalArticle> orderByComparator) {
3707                    return getPersistence()
3708                                       .filterFindByG_L(groupId, layoutUuid, start, end,
3709                            orderByComparator);
3710            }
3711    
3712            /**
3713            * 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;.
3714            *
3715            * @param id the primary key of the current journal article
3716            * @param groupId the group ID
3717            * @param layoutUuid the layout uuid
3718            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3719            * @return the previous, current, and next journal article
3720            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3721            */
3722            public static JournalArticle[] filterFindByG_L_PrevAndNext(long id,
3723                    long groupId, java.lang.String layoutUuid,
3724                    OrderByComparator<JournalArticle> orderByComparator)
3725                    throws com.liferay.portlet.journal.NoSuchArticleException {
3726                    return getPersistence()
3727                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
3728                            orderByComparator);
3729            }
3730    
3731            /**
3732            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
3733            *
3734            * @param groupId the group ID
3735            * @param layoutUuid the layout uuid
3736            */
3737            public static void removeByG_L(long groupId, java.lang.String layoutUuid) {
3738                    getPersistence().removeByG_L(groupId, layoutUuid);
3739            }
3740    
3741            /**
3742            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
3743            *
3744            * @param groupId the group ID
3745            * @param layoutUuid the layout uuid
3746            * @return the number of matching journal articles
3747            */
3748            public static int countByG_L(long groupId, java.lang.String layoutUuid) {
3749                    return getPersistence().countByG_L(groupId, layoutUuid);
3750            }
3751    
3752            /**
3753            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
3754            *
3755            * @param groupId the group ID
3756            * @param layoutUuid the layout uuid
3757            * @return the number of matching journal articles that the user has permission to view
3758            */
3759            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) {
3760                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
3761            }
3762    
3763            /**
3764            * Returns all the journal articles where groupId = &#63; and status = &#63;.
3765            *
3766            * @param groupId the group ID
3767            * @param status the status
3768            * @return the matching journal articles
3769            */
3770            public static List<JournalArticle> findByG_ST(long groupId, int status) {
3771                    return getPersistence().findByG_ST(groupId, status);
3772            }
3773    
3774            /**
3775            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
3776            *
3777            * <p>
3778            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3779            * </p>
3780            *
3781            * @param groupId the group ID
3782            * @param status the status
3783            * @param start the lower bound of the range of journal articles
3784            * @param end the upper bound of the range of journal articles (not inclusive)
3785            * @return the range of matching journal articles
3786            */
3787            public static List<JournalArticle> findByG_ST(long groupId, int status,
3788                    int start, int end) {
3789                    return getPersistence().findByG_ST(groupId, status, start, end);
3790            }
3791    
3792            /**
3793            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
3794            *
3795            * <p>
3796            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3797            * </p>
3798            *
3799            * @param groupId the group ID
3800            * @param status the status
3801            * @param start the lower bound of the range of journal articles
3802            * @param end the upper bound of the range of journal articles (not inclusive)
3803            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3804            * @return the ordered range of matching journal articles
3805            */
3806            public static List<JournalArticle> findByG_ST(long groupId, int status,
3807                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
3808                    return getPersistence()
3809                                       .findByG_ST(groupId, status, start, end, orderByComparator);
3810            }
3811    
3812            /**
3813            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
3814            *
3815            * @param groupId the group ID
3816            * @param status the status
3817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3818            * @return the first matching journal article
3819            * @throws NoSuchArticleException if a matching journal article could not be found
3820            */
3821            public static JournalArticle findByG_ST_First(long groupId, int status,
3822                    OrderByComparator<JournalArticle> orderByComparator)
3823                    throws com.liferay.portlet.journal.NoSuchArticleException {
3824                    return getPersistence()
3825                                       .findByG_ST_First(groupId, status, orderByComparator);
3826            }
3827    
3828            /**
3829            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
3830            *
3831            * @param groupId the group ID
3832            * @param status the status
3833            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3834            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
3835            */
3836            public static JournalArticle fetchByG_ST_First(long groupId, int status,
3837                    OrderByComparator<JournalArticle> orderByComparator) {
3838                    return getPersistence()
3839                                       .fetchByG_ST_First(groupId, status, orderByComparator);
3840            }
3841    
3842            /**
3843            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
3844            *
3845            * @param groupId the group ID
3846            * @param status the status
3847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3848            * @return the last matching journal article
3849            * @throws NoSuchArticleException if a matching journal article could not be found
3850            */
3851            public static JournalArticle findByG_ST_Last(long groupId, int status,
3852                    OrderByComparator<JournalArticle> orderByComparator)
3853                    throws com.liferay.portlet.journal.NoSuchArticleException {
3854                    return getPersistence()
3855                                       .findByG_ST_Last(groupId, status, orderByComparator);
3856            }
3857    
3858            /**
3859            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
3860            *
3861            * @param groupId the group ID
3862            * @param status the status
3863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3864            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
3865            */
3866            public static JournalArticle fetchByG_ST_Last(long groupId, int status,
3867                    OrderByComparator<JournalArticle> orderByComparator) {
3868                    return getPersistence()
3869                                       .fetchByG_ST_Last(groupId, status, orderByComparator);
3870            }
3871    
3872            /**
3873            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
3874            *
3875            * @param id the primary key of the current journal article
3876            * @param groupId the group ID
3877            * @param status the status
3878            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3879            * @return the previous, current, and next journal article
3880            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3881            */
3882            public static JournalArticle[] findByG_ST_PrevAndNext(long id,
3883                    long groupId, int status,
3884                    OrderByComparator<JournalArticle> orderByComparator)
3885                    throws com.liferay.portlet.journal.NoSuchArticleException {
3886                    return getPersistence()
3887                                       .findByG_ST_PrevAndNext(id, groupId, status,
3888                            orderByComparator);
3889            }
3890    
3891            /**
3892            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3893            *
3894            * @param groupId the group ID
3895            * @param status the status
3896            * @return the matching journal articles that the user has permission to view
3897            */
3898            public static List<JournalArticle> filterFindByG_ST(long groupId, int status) {
3899                    return getPersistence().filterFindByG_ST(groupId, status);
3900            }
3901    
3902            /**
3903            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3904            *
3905            * <p>
3906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3907            * </p>
3908            *
3909            * @param groupId the group ID
3910            * @param status the status
3911            * @param start the lower bound of the range of journal articles
3912            * @param end the upper bound of the range of journal articles (not inclusive)
3913            * @return the range of matching journal articles that the user has permission to view
3914            */
3915            public static List<JournalArticle> filterFindByG_ST(long groupId,
3916                    int status, int start, int end) {
3917                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
3918            }
3919    
3920            /**
3921            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
3922            *
3923            * <p>
3924            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
3925            * </p>
3926            *
3927            * @param groupId the group ID
3928            * @param status the status
3929            * @param start the lower bound of the range of journal articles
3930            * @param end the upper bound of the range of journal articles (not inclusive)
3931            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3932            * @return the ordered range of matching journal articles that the user has permission to view
3933            */
3934            public static List<JournalArticle> filterFindByG_ST(long groupId,
3935                    int status, int start, int end,
3936                    OrderByComparator<JournalArticle> orderByComparator) {
3937                    return getPersistence()
3938                                       .filterFindByG_ST(groupId, status, start, end,
3939                            orderByComparator);
3940            }
3941    
3942            /**
3943            * 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;.
3944            *
3945            * @param id the primary key of the current journal article
3946            * @param groupId the group ID
3947            * @param status the status
3948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3949            * @return the previous, current, and next journal article
3950            * @throws NoSuchArticleException if a journal article with the primary key could not be found
3951            */
3952            public static JournalArticle[] filterFindByG_ST_PrevAndNext(long id,
3953                    long groupId, int status,
3954                    OrderByComparator<JournalArticle> orderByComparator)
3955                    throws com.liferay.portlet.journal.NoSuchArticleException {
3956                    return getPersistence()
3957                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
3958                            orderByComparator);
3959            }
3960    
3961            /**
3962            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
3963            *
3964            * @param groupId the group ID
3965            * @param status the status
3966            */
3967            public static void removeByG_ST(long groupId, int status) {
3968                    getPersistence().removeByG_ST(groupId, status);
3969            }
3970    
3971            /**
3972            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
3973            *
3974            * @param groupId the group ID
3975            * @param status the status
3976            * @return the number of matching journal articles
3977            */
3978            public static int countByG_ST(long groupId, int status) {
3979                    return getPersistence().countByG_ST(groupId, status);
3980            }
3981    
3982            /**
3983            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
3984            *
3985            * @param groupId the group ID
3986            * @param status the status
3987            * @return the number of matching journal articles that the user has permission to view
3988            */
3989            public static int filterCountByG_ST(long groupId, int status) {
3990                    return getPersistence().filterCountByG_ST(groupId, status);
3991            }
3992    
3993            /**
3994            * Returns all the journal articles where companyId = &#63; and version = &#63;.
3995            *
3996            * @param companyId the company ID
3997            * @param version the version
3998            * @return the matching journal articles
3999            */
4000            public static List<JournalArticle> findByC_V(long companyId, double version) {
4001                    return getPersistence().findByC_V(companyId, version);
4002            }
4003    
4004            /**
4005            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
4006            *
4007            * <p>
4008            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4009            * </p>
4010            *
4011            * @param companyId the company ID
4012            * @param version the version
4013            * @param start the lower bound of the range of journal articles
4014            * @param end the upper bound of the range of journal articles (not inclusive)
4015            * @return the range of matching journal articles
4016            */
4017            public static List<JournalArticle> findByC_V(long companyId,
4018                    double version, int start, int end) {
4019                    return getPersistence().findByC_V(companyId, version, start, end);
4020            }
4021    
4022            /**
4023            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
4024            *
4025            * <p>
4026            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4027            * </p>
4028            *
4029            * @param companyId the company ID
4030            * @param version the version
4031            * @param start the lower bound of the range of journal articles
4032            * @param end the upper bound of the range of journal articles (not inclusive)
4033            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4034            * @return the ordered range of matching journal articles
4035            */
4036            public static List<JournalArticle> findByC_V(long companyId,
4037                    double version, int start, int end,
4038                    OrderByComparator<JournalArticle> orderByComparator) {
4039                    return getPersistence()
4040                                       .findByC_V(companyId, version, start, end, orderByComparator);
4041            }
4042    
4043            /**
4044            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4045            *
4046            * @param companyId the company ID
4047            * @param version the version
4048            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4049            * @return the first matching journal article
4050            * @throws NoSuchArticleException if a matching journal article could not be found
4051            */
4052            public static JournalArticle findByC_V_First(long companyId,
4053                    double version, OrderByComparator<JournalArticle> orderByComparator)
4054                    throws com.liferay.portlet.journal.NoSuchArticleException {
4055                    return getPersistence()
4056                                       .findByC_V_First(companyId, version, orderByComparator);
4057            }
4058    
4059            /**
4060            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
4061            *
4062            * @param companyId the company ID
4063            * @param version the version
4064            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4065            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4066            */
4067            public static JournalArticle fetchByC_V_First(long companyId,
4068                    double version, OrderByComparator<JournalArticle> orderByComparator) {
4069                    return getPersistence()
4070                                       .fetchByC_V_First(companyId, version, orderByComparator);
4071            }
4072    
4073            /**
4074            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4075            *
4076            * @param companyId the company ID
4077            * @param version the version
4078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4079            * @return the last matching journal article
4080            * @throws NoSuchArticleException if a matching journal article could not be found
4081            */
4082            public static JournalArticle findByC_V_Last(long companyId, double version,
4083                    OrderByComparator<JournalArticle> orderByComparator)
4084                    throws com.liferay.portlet.journal.NoSuchArticleException {
4085                    return getPersistence()
4086                                       .findByC_V_Last(companyId, version, orderByComparator);
4087            }
4088    
4089            /**
4090            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
4091            *
4092            * @param companyId the company ID
4093            * @param version the version
4094            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4095            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4096            */
4097            public static JournalArticle fetchByC_V_Last(long companyId,
4098                    double version, OrderByComparator<JournalArticle> orderByComparator) {
4099                    return getPersistence()
4100                                       .fetchByC_V_Last(companyId, version, orderByComparator);
4101            }
4102    
4103            /**
4104            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
4105            *
4106            * @param id the primary key of the current journal article
4107            * @param companyId the company ID
4108            * @param version the version
4109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4110            * @return the previous, current, and next journal article
4111            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4112            */
4113            public static JournalArticle[] findByC_V_PrevAndNext(long id,
4114                    long companyId, double version,
4115                    OrderByComparator<JournalArticle> orderByComparator)
4116                    throws com.liferay.portlet.journal.NoSuchArticleException {
4117                    return getPersistence()
4118                                       .findByC_V_PrevAndNext(id, companyId, version,
4119                            orderByComparator);
4120            }
4121    
4122            /**
4123            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4124            *
4125            * @param companyId the company ID
4126            * @param version the version
4127            */
4128            public static void removeByC_V(long companyId, double version) {
4129                    getPersistence().removeByC_V(companyId, version);
4130            }
4131    
4132            /**
4133            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4134            *
4135            * @param companyId the company ID
4136            * @param version the version
4137            * @return the number of matching journal articles
4138            */
4139            public static int countByC_V(long companyId, double version) {
4140                    return getPersistence().countByC_V(companyId, version);
4141            }
4142    
4143            /**
4144            * Returns all the journal articles where companyId = &#63; and status = &#63;.
4145            *
4146            * @param companyId the company ID
4147            * @param status the status
4148            * @return the matching journal articles
4149            */
4150            public static List<JournalArticle> findByC_ST(long companyId, int status) {
4151                    return getPersistence().findByC_ST(companyId, status);
4152            }
4153    
4154            /**
4155            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
4156            *
4157            * <p>
4158            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4159            * </p>
4160            *
4161            * @param companyId the company ID
4162            * @param status the status
4163            * @param start the lower bound of the range of journal articles
4164            * @param end the upper bound of the range of journal articles (not inclusive)
4165            * @return the range of matching journal articles
4166            */
4167            public static List<JournalArticle> findByC_ST(long companyId, int status,
4168                    int start, int end) {
4169                    return getPersistence().findByC_ST(companyId, status, start, end);
4170            }
4171    
4172            /**
4173            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
4174            *
4175            * <p>
4176            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4177            * </p>
4178            *
4179            * @param companyId the company ID
4180            * @param status the status
4181            * @param start the lower bound of the range of journal articles
4182            * @param end the upper bound of the range of journal articles (not inclusive)
4183            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4184            * @return the ordered range of matching journal articles
4185            */
4186            public static List<JournalArticle> findByC_ST(long companyId, int status,
4187                    int start, int end, OrderByComparator<JournalArticle> orderByComparator) {
4188                    return getPersistence()
4189                                       .findByC_ST(companyId, status, start, end, orderByComparator);
4190            }
4191    
4192            /**
4193            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4194            *
4195            * @param companyId the company ID
4196            * @param status the status
4197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4198            * @return the first matching journal article
4199            * @throws NoSuchArticleException if a matching journal article could not be found
4200            */
4201            public static JournalArticle findByC_ST_First(long companyId, int status,
4202                    OrderByComparator<JournalArticle> orderByComparator)
4203                    throws com.liferay.portlet.journal.NoSuchArticleException {
4204                    return getPersistence()
4205                                       .findByC_ST_First(companyId, status, orderByComparator);
4206            }
4207    
4208            /**
4209            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
4210            *
4211            * @param companyId the company ID
4212            * @param status the status
4213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4214            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4215            */
4216            public static JournalArticle fetchByC_ST_First(long companyId, int status,
4217                    OrderByComparator<JournalArticle> orderByComparator) {
4218                    return getPersistence()
4219                                       .fetchByC_ST_First(companyId, status, orderByComparator);
4220            }
4221    
4222            /**
4223            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
4224            *
4225            * @param companyId the company ID
4226            * @param status the status
4227            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4228            * @return the last matching journal article
4229            * @throws NoSuchArticleException if a matching journal article could not be found
4230            */
4231            public static JournalArticle findByC_ST_Last(long companyId, int status,
4232                    OrderByComparator<JournalArticle> orderByComparator)
4233                    throws com.liferay.portlet.journal.NoSuchArticleException {
4234                    return getPersistence()
4235                                       .findByC_ST_Last(companyId, status, orderByComparator);
4236            }
4237    
4238            /**
4239            * Returns the last 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 last matching journal article, or <code>null</code> if a matching journal article could not be found
4245            */
4246            public static JournalArticle fetchByC_ST_Last(long companyId, int status,
4247                    OrderByComparator<JournalArticle> orderByComparator) {
4248                    return getPersistence()
4249                                       .fetchByC_ST_Last(companyId, status, orderByComparator);
4250            }
4251    
4252            /**
4253            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
4254            *
4255            * @param id the primary key of the current journal article
4256            * @param companyId the company ID
4257            * @param status the status
4258            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4259            * @return the previous, current, and next journal article
4260            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4261            */
4262            public static JournalArticle[] findByC_ST_PrevAndNext(long id,
4263                    long companyId, int status,
4264                    OrderByComparator<JournalArticle> orderByComparator)
4265                    throws com.liferay.portlet.journal.NoSuchArticleException {
4266                    return getPersistence()
4267                                       .findByC_ST_PrevAndNext(id, companyId, status,
4268                            orderByComparator);
4269            }
4270    
4271            /**
4272            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4273            *
4274            * @param companyId the company ID
4275            * @param status the status
4276            */
4277            public static void removeByC_ST(long companyId, int status) {
4278                    getPersistence().removeByC_ST(companyId, status);
4279            }
4280    
4281            /**
4282            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4283            *
4284            * @param companyId the company ID
4285            * @param status the status
4286            * @return the number of matching journal articles
4287            */
4288            public static int countByC_ST(long companyId, int status) {
4289                    return getPersistence().countByC_ST(companyId, status);
4290            }
4291    
4292            /**
4293            * Returns all the journal articles where companyId = &#63; and status &ne; &#63;.
4294            *
4295            * @param companyId the company ID
4296            * @param status the status
4297            * @return the matching journal articles
4298            */
4299            public static List<JournalArticle> findByC_NotST(long companyId, int status) {
4300                    return getPersistence().findByC_NotST(companyId, status);
4301            }
4302    
4303            /**
4304            * Returns a range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4305            *
4306            * <p>
4307            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4308            * </p>
4309            *
4310            * @param companyId the company ID
4311            * @param status the status
4312            * @param start the lower bound of the range of journal articles
4313            * @param end the upper bound of the range of journal articles (not inclusive)
4314            * @return the range of matching journal articles
4315            */
4316            public static List<JournalArticle> findByC_NotST(long companyId,
4317                    int status, int start, int end) {
4318                    return getPersistence().findByC_NotST(companyId, status, start, end);
4319            }
4320    
4321            /**
4322            * Returns an ordered range of all the journal articles where companyId = &#63; and status &ne; &#63;.
4323            *
4324            * <p>
4325            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4326            * </p>
4327            *
4328            * @param companyId the company ID
4329            * @param status the status
4330            * @param start the lower bound of the range of journal articles
4331            * @param end the upper bound of the range of journal articles (not inclusive)
4332            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4333            * @return the ordered range of matching journal articles
4334            */
4335            public static List<JournalArticle> findByC_NotST(long companyId,
4336                    int status, int start, int end,
4337                    OrderByComparator<JournalArticle> orderByComparator) {
4338                    return getPersistence()
4339                                       .findByC_NotST(companyId, status, start, end,
4340                            orderByComparator);
4341            }
4342    
4343            /**
4344            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4345            *
4346            * @param companyId the company ID
4347            * @param status the status
4348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4349            * @return the first matching journal article
4350            * @throws NoSuchArticleException if a matching journal article could not be found
4351            */
4352            public static JournalArticle findByC_NotST_First(long companyId,
4353                    int status, OrderByComparator<JournalArticle> orderByComparator)
4354                    throws com.liferay.portlet.journal.NoSuchArticleException {
4355                    return getPersistence()
4356                                       .findByC_NotST_First(companyId, status, orderByComparator);
4357            }
4358    
4359            /**
4360            * Returns the first journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4361            *
4362            * @param companyId the company ID
4363            * @param status the status
4364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4365            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4366            */
4367            public static JournalArticle fetchByC_NotST_First(long companyId,
4368                    int status, OrderByComparator<JournalArticle> orderByComparator) {
4369                    return getPersistence()
4370                                       .fetchByC_NotST_First(companyId, status, orderByComparator);
4371            }
4372    
4373            /**
4374            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4375            *
4376            * @param companyId the company ID
4377            * @param status the status
4378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4379            * @return the last matching journal article
4380            * @throws NoSuchArticleException if a matching journal article could not be found
4381            */
4382            public static JournalArticle findByC_NotST_Last(long companyId, int status,
4383                    OrderByComparator<JournalArticle> orderByComparator)
4384                    throws com.liferay.portlet.journal.NoSuchArticleException {
4385                    return getPersistence()
4386                                       .findByC_NotST_Last(companyId, status, orderByComparator);
4387            }
4388    
4389            /**
4390            * Returns the last journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4391            *
4392            * @param companyId the company ID
4393            * @param status the status
4394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4395            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4396            */
4397            public static JournalArticle fetchByC_NotST_Last(long companyId,
4398                    int status, OrderByComparator<JournalArticle> orderByComparator) {
4399                    return getPersistence()
4400                                       .fetchByC_NotST_Last(companyId, status, orderByComparator);
4401            }
4402    
4403            /**
4404            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status &ne; &#63;.
4405            *
4406            * @param id the primary key of the current journal article
4407            * @param companyId the company ID
4408            * @param status the status
4409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4410            * @return the previous, current, and next journal article
4411            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4412            */
4413            public static JournalArticle[] findByC_NotST_PrevAndNext(long id,
4414                    long companyId, int status,
4415                    OrderByComparator<JournalArticle> orderByComparator)
4416                    throws com.liferay.portlet.journal.NoSuchArticleException {
4417                    return getPersistence()
4418                                       .findByC_NotST_PrevAndNext(id, companyId, status,
4419                            orderByComparator);
4420            }
4421    
4422            /**
4423            * Removes all the journal articles where companyId = &#63; and status &ne; &#63; from the database.
4424            *
4425            * @param companyId the company ID
4426            * @param status the status
4427            */
4428            public static void removeByC_NotST(long companyId, int status) {
4429                    getPersistence().removeByC_NotST(companyId, status);
4430            }
4431    
4432            /**
4433            * Returns the number of journal articles where companyId = &#63; and status &ne; &#63;.
4434            *
4435            * @param companyId the company ID
4436            * @param status the status
4437            * @return the number of matching journal articles
4438            */
4439            public static int countByC_NotST(long companyId, int status) {
4440                    return getPersistence().countByC_NotST(companyId, status);
4441            }
4442    
4443            /**
4444            * Returns all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
4445            *
4446            * @param classNameId the class name ID
4447            * @param DDMTemplateKey the d d m template key
4448            * @return the matching journal articles
4449            */
4450            public static List<JournalArticle> findByC_DDMTK(long classNameId,
4451                    java.lang.String DDMTemplateKey) {
4452                    return getPersistence().findByC_DDMTK(classNameId, DDMTemplateKey);
4453            }
4454    
4455            /**
4456            * Returns a range of all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
4457            *
4458            * <p>
4459            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4460            * </p>
4461            *
4462            * @param classNameId the class name ID
4463            * @param DDMTemplateKey the d d m template key
4464            * @param start the lower bound of the range of journal articles
4465            * @param end the upper bound of the range of journal articles (not inclusive)
4466            * @return the range of matching journal articles
4467            */
4468            public static List<JournalArticle> findByC_DDMTK(long classNameId,
4469                    java.lang.String DDMTemplateKey, int start, int end) {
4470                    return getPersistence()
4471                                       .findByC_DDMTK(classNameId, DDMTemplateKey, start, end);
4472            }
4473    
4474            /**
4475            * Returns an ordered range of all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
4476            *
4477            * <p>
4478            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4479            * </p>
4480            *
4481            * @param classNameId the class name ID
4482            * @param DDMTemplateKey the d d m template key
4483            * @param start the lower bound of the range of journal articles
4484            * @param end the upper bound of the range of journal articles (not inclusive)
4485            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4486            * @return the ordered range of matching journal articles
4487            */
4488            public static List<JournalArticle> findByC_DDMTK(long classNameId,
4489                    java.lang.String DDMTemplateKey, int start, int end,
4490                    OrderByComparator<JournalArticle> orderByComparator) {
4491                    return getPersistence()
4492                                       .findByC_DDMTK(classNameId, DDMTemplateKey, start, end,
4493                            orderByComparator);
4494            }
4495    
4496            /**
4497            * Returns the first journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
4498            *
4499            * @param classNameId the class name ID
4500            * @param DDMTemplateKey the d d m template key
4501            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4502            * @return the first matching journal article
4503            * @throws NoSuchArticleException if a matching journal article could not be found
4504            */
4505            public static JournalArticle findByC_DDMTK_First(long classNameId,
4506                    java.lang.String DDMTemplateKey,
4507                    OrderByComparator<JournalArticle> orderByComparator)
4508                    throws com.liferay.portlet.journal.NoSuchArticleException {
4509                    return getPersistence()
4510                                       .findByC_DDMTK_First(classNameId, DDMTemplateKey,
4511                            orderByComparator);
4512            }
4513    
4514            /**
4515            * Returns the first journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
4516            *
4517            * @param classNameId the class name ID
4518            * @param DDMTemplateKey the d d m template key
4519            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4520            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4521            */
4522            public static JournalArticle fetchByC_DDMTK_First(long classNameId,
4523                    java.lang.String DDMTemplateKey,
4524                    OrderByComparator<JournalArticle> orderByComparator) {
4525                    return getPersistence()
4526                                       .fetchByC_DDMTK_First(classNameId, DDMTemplateKey,
4527                            orderByComparator);
4528            }
4529    
4530            /**
4531            * Returns the last journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
4532            *
4533            * @param classNameId the class name ID
4534            * @param DDMTemplateKey the d d m template key
4535            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4536            * @return the last matching journal article
4537            * @throws NoSuchArticleException if a matching journal article could not be found
4538            */
4539            public static JournalArticle findByC_DDMTK_Last(long classNameId,
4540                    java.lang.String DDMTemplateKey,
4541                    OrderByComparator<JournalArticle> orderByComparator)
4542                    throws com.liferay.portlet.journal.NoSuchArticleException {
4543                    return getPersistence()
4544                                       .findByC_DDMTK_Last(classNameId, DDMTemplateKey,
4545                            orderByComparator);
4546            }
4547    
4548            /**
4549            * Returns the last journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
4550            *
4551            * @param classNameId the class name ID
4552            * @param DDMTemplateKey the d d m template key
4553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4554            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4555            */
4556            public static JournalArticle fetchByC_DDMTK_Last(long classNameId,
4557                    java.lang.String DDMTemplateKey,
4558                    OrderByComparator<JournalArticle> orderByComparator) {
4559                    return getPersistence()
4560                                       .fetchByC_DDMTK_Last(classNameId, DDMTemplateKey,
4561                            orderByComparator);
4562            }
4563    
4564            /**
4565            * Returns the journal articles before and after the current journal article in the ordered set where classNameId = &#63; and DDMTemplateKey = &#63;.
4566            *
4567            * @param id the primary key of the current journal article
4568            * @param classNameId the class name ID
4569            * @param DDMTemplateKey the d d m template key
4570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4571            * @return the previous, current, and next journal article
4572            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4573            */
4574            public static JournalArticle[] findByC_DDMTK_PrevAndNext(long id,
4575                    long classNameId, java.lang.String DDMTemplateKey,
4576                    OrderByComparator<JournalArticle> orderByComparator)
4577                    throws com.liferay.portlet.journal.NoSuchArticleException {
4578                    return getPersistence()
4579                                       .findByC_DDMTK_PrevAndNext(id, classNameId, DDMTemplateKey,
4580                            orderByComparator);
4581            }
4582    
4583            /**
4584            * Removes all the journal articles where classNameId = &#63; and DDMTemplateKey = &#63; from the database.
4585            *
4586            * @param classNameId the class name ID
4587            * @param DDMTemplateKey the d d m template key
4588            */
4589            public static void removeByC_DDMTK(long classNameId,
4590                    java.lang.String DDMTemplateKey) {
4591                    getPersistence().removeByC_DDMTK(classNameId, DDMTemplateKey);
4592            }
4593    
4594            /**
4595            * Returns the number of journal articles where classNameId = &#63; and DDMTemplateKey = &#63;.
4596            *
4597            * @param classNameId the class name ID
4598            * @param DDMTemplateKey the d d m template key
4599            * @return the number of matching journal articles
4600            */
4601            public static int countByC_DDMTK(long classNameId,
4602                    java.lang.String DDMTemplateKey) {
4603                    return getPersistence().countByC_DDMTK(classNameId, DDMTemplateKey);
4604            }
4605    
4606            /**
4607            * Returns all the journal articles where displayDate &lt; &#63; and status = &#63;.
4608            *
4609            * @param displayDate the display date
4610            * @param status the status
4611            * @return the matching journal articles
4612            */
4613            public static List<JournalArticle> findByLtD_S(java.util.Date displayDate,
4614                    int status) {
4615                    return getPersistence().findByLtD_S(displayDate, status);
4616            }
4617    
4618            /**
4619            * Returns a range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
4620            *
4621            * <p>
4622            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4623            * </p>
4624            *
4625            * @param displayDate the display date
4626            * @param status the status
4627            * @param start the lower bound of the range of journal articles
4628            * @param end the upper bound of the range of journal articles (not inclusive)
4629            * @return the range of matching journal articles
4630            */
4631            public static List<JournalArticle> findByLtD_S(java.util.Date displayDate,
4632                    int status, int start, int end) {
4633                    return getPersistence().findByLtD_S(displayDate, status, start, end);
4634            }
4635    
4636            /**
4637            * Returns an ordered range of all the journal articles where displayDate &lt; &#63; and status = &#63;.
4638            *
4639            * <p>
4640            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4641            * </p>
4642            *
4643            * @param displayDate the display date
4644            * @param status the status
4645            * @param start the lower bound of the range of journal articles
4646            * @param end the upper bound of the range of journal articles (not inclusive)
4647            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4648            * @return the ordered range of matching journal articles
4649            */
4650            public static List<JournalArticle> findByLtD_S(java.util.Date displayDate,
4651                    int status, int start, int end,
4652                    OrderByComparator<JournalArticle> orderByComparator) {
4653                    return getPersistence()
4654                                       .findByLtD_S(displayDate, status, start, end,
4655                            orderByComparator);
4656            }
4657    
4658            /**
4659            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4660            *
4661            * @param displayDate the display date
4662            * @param status the status
4663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4664            * @return the first matching journal article
4665            * @throws NoSuchArticleException if a matching journal article could not be found
4666            */
4667            public static JournalArticle findByLtD_S_First(java.util.Date displayDate,
4668                    int status, OrderByComparator<JournalArticle> orderByComparator)
4669                    throws com.liferay.portlet.journal.NoSuchArticleException {
4670                    return getPersistence()
4671                                       .findByLtD_S_First(displayDate, status, orderByComparator);
4672            }
4673    
4674            /**
4675            * Returns the first journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4676            *
4677            * @param displayDate the display date
4678            * @param status the status
4679            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4680            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4681            */
4682            public static JournalArticle fetchByLtD_S_First(
4683                    java.util.Date displayDate, int status,
4684                    OrderByComparator<JournalArticle> orderByComparator) {
4685                    return getPersistence()
4686                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
4687            }
4688    
4689            /**
4690            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4691            *
4692            * @param displayDate the display date
4693            * @param status the status
4694            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4695            * @return the last matching journal article
4696            * @throws NoSuchArticleException if a matching journal article could not be found
4697            */
4698            public static JournalArticle findByLtD_S_Last(java.util.Date displayDate,
4699                    int status, OrderByComparator<JournalArticle> orderByComparator)
4700                    throws com.liferay.portlet.journal.NoSuchArticleException {
4701                    return getPersistence()
4702                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
4703            }
4704    
4705            /**
4706            * Returns the last journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4707            *
4708            * @param displayDate the display date
4709            * @param status the status
4710            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4711            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4712            */
4713            public static JournalArticle fetchByLtD_S_Last(java.util.Date displayDate,
4714                    int status, OrderByComparator<JournalArticle> orderByComparator) {
4715                    return getPersistence()
4716                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
4717            }
4718    
4719            /**
4720            * Returns the journal articles before and after the current journal article in the ordered set where displayDate &lt; &#63; and status = &#63;.
4721            *
4722            * @param id the primary key of the current journal article
4723            * @param displayDate the display date
4724            * @param status the status
4725            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4726            * @return the previous, current, and next journal article
4727            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4728            */
4729            public static JournalArticle[] findByLtD_S_PrevAndNext(long id,
4730                    java.util.Date displayDate, int status,
4731                    OrderByComparator<JournalArticle> orderByComparator)
4732                    throws com.liferay.portlet.journal.NoSuchArticleException {
4733                    return getPersistence()
4734                                       .findByLtD_S_PrevAndNext(id, displayDate, status,
4735                            orderByComparator);
4736            }
4737    
4738            /**
4739            * Removes all the journal articles where displayDate &lt; &#63; and status = &#63; from the database.
4740            *
4741            * @param displayDate the display date
4742            * @param status the status
4743            */
4744            public static void removeByLtD_S(java.util.Date displayDate, int status) {
4745                    getPersistence().removeByLtD_S(displayDate, status);
4746            }
4747    
4748            /**
4749            * Returns the number of journal articles where displayDate &lt; &#63; and status = &#63;.
4750            *
4751            * @param displayDate the display date
4752            * @param status the status
4753            * @return the number of matching journal articles
4754            */
4755            public static int countByLtD_S(java.util.Date displayDate, int status) {
4756                    return getPersistence().countByLtD_S(displayDate, status);
4757            }
4758    
4759            /**
4760            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4761            *
4762            * @param resourcePrimKey the resource prim key
4763            * @param indexable the indexable
4764            * @param status the status
4765            * @return the matching journal articles
4766            */
4767            public static List<JournalArticle> findByR_I_S(long resourcePrimKey,
4768                    boolean indexable, int status) {
4769                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, status);
4770            }
4771    
4772            /**
4773            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4774            *
4775            * <p>
4776            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4777            * </p>
4778            *
4779            * @param resourcePrimKey the resource prim key
4780            * @param indexable the indexable
4781            * @param status the status
4782            * @param start the lower bound of the range of journal articles
4783            * @param end the upper bound of the range of journal articles (not inclusive)
4784            * @return the range of matching journal articles
4785            */
4786            public static List<JournalArticle> findByR_I_S(long resourcePrimKey,
4787                    boolean indexable, int status, int start, int end) {
4788                    return getPersistence()
4789                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end);
4790            }
4791    
4792            /**
4793            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4794            *
4795            * <p>
4796            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4797            * </p>
4798            *
4799            * @param resourcePrimKey the resource prim key
4800            * @param indexable the indexable
4801            * @param status the status
4802            * @param start the lower bound of the range of journal articles
4803            * @param end the upper bound of the range of journal articles (not inclusive)
4804            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4805            * @return the ordered range of matching journal articles
4806            */
4807            public static List<JournalArticle> findByR_I_S(long resourcePrimKey,
4808                    boolean indexable, int status, int start, int end,
4809                    OrderByComparator<JournalArticle> orderByComparator) {
4810                    return getPersistence()
4811                                       .findByR_I_S(resourcePrimKey, indexable, status, start, end,
4812                            orderByComparator);
4813            }
4814    
4815            /**
4816            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4817            *
4818            * @param resourcePrimKey the resource prim key
4819            * @param indexable the indexable
4820            * @param status the status
4821            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4822            * @return the first matching journal article
4823            * @throws NoSuchArticleException if a matching journal article could not be found
4824            */
4825            public static JournalArticle findByR_I_S_First(long resourcePrimKey,
4826                    boolean indexable, int status,
4827                    OrderByComparator<JournalArticle> orderByComparator)
4828                    throws com.liferay.portlet.journal.NoSuchArticleException {
4829                    return getPersistence()
4830                                       .findByR_I_S_First(resourcePrimKey, indexable, status,
4831                            orderByComparator);
4832            }
4833    
4834            /**
4835            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4836            *
4837            * @param resourcePrimKey the resource prim key
4838            * @param indexable the indexable
4839            * @param status the status
4840            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4841            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
4842            */
4843            public static JournalArticle fetchByR_I_S_First(long resourcePrimKey,
4844                    boolean indexable, int status,
4845                    OrderByComparator<JournalArticle> orderByComparator) {
4846                    return getPersistence()
4847                                       .fetchByR_I_S_First(resourcePrimKey, indexable, status,
4848                            orderByComparator);
4849            }
4850    
4851            /**
4852            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4853            *
4854            * @param resourcePrimKey the resource prim key
4855            * @param indexable the indexable
4856            * @param status the status
4857            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4858            * @return the last matching journal article
4859            * @throws NoSuchArticleException if a matching journal article could not be found
4860            */
4861            public static JournalArticle findByR_I_S_Last(long resourcePrimKey,
4862                    boolean indexable, int status,
4863                    OrderByComparator<JournalArticle> orderByComparator)
4864                    throws com.liferay.portlet.journal.NoSuchArticleException {
4865                    return getPersistence()
4866                                       .findByR_I_S_Last(resourcePrimKey, indexable, status,
4867                            orderByComparator);
4868            }
4869    
4870            /**
4871            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4872            *
4873            * @param resourcePrimKey the resource prim key
4874            * @param indexable the indexable
4875            * @param status the status
4876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4877            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
4878            */
4879            public static JournalArticle fetchByR_I_S_Last(long resourcePrimKey,
4880                    boolean indexable, int status,
4881                    OrderByComparator<JournalArticle> orderByComparator) {
4882                    return getPersistence()
4883                                       .fetchByR_I_S_Last(resourcePrimKey, indexable, status,
4884                            orderByComparator);
4885            }
4886    
4887            /**
4888            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4889            *
4890            * @param id the primary key of the current journal article
4891            * @param resourcePrimKey the resource prim key
4892            * @param indexable the indexable
4893            * @param status the status
4894            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4895            * @return the previous, current, and next journal article
4896            * @throws NoSuchArticleException if a journal article with the primary key could not be found
4897            */
4898            public static JournalArticle[] findByR_I_S_PrevAndNext(long id,
4899                    long resourcePrimKey, boolean indexable, int status,
4900                    OrderByComparator<JournalArticle> orderByComparator)
4901                    throws com.liferay.portlet.journal.NoSuchArticleException {
4902                    return getPersistence()
4903                                       .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable,
4904                            status, orderByComparator);
4905            }
4906    
4907            /**
4908            * Returns all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4909            *
4910            * <p>
4911            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4912            * </p>
4913            *
4914            * @param resourcePrimKey the resource prim key
4915            * @param indexable the indexable
4916            * @param statuses the statuses
4917            * @return the matching journal articles
4918            */
4919            public static List<JournalArticle> findByR_I_S(long resourcePrimKey,
4920                    boolean indexable, int[] statuses) {
4921                    return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses);
4922            }
4923    
4924            /**
4925            * Returns a range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4926            *
4927            * <p>
4928            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4929            * </p>
4930            *
4931            * @param resourcePrimKey the resource prim key
4932            * @param indexable the indexable
4933            * @param statuses the statuses
4934            * @param start the lower bound of the range of journal articles
4935            * @param end the upper bound of the range of journal articles (not inclusive)
4936            * @return the range of matching journal articles
4937            */
4938            public static List<JournalArticle> findByR_I_S(long resourcePrimKey,
4939                    boolean indexable, int[] statuses, int start, int end) {
4940                    return getPersistence()
4941                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start, end);
4942            }
4943    
4944            /**
4945            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4946            *
4947            * <p>
4948            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
4949            * </p>
4950            *
4951            * @param resourcePrimKey the resource prim key
4952            * @param indexable the indexable
4953            * @param statuses the statuses
4954            * @param start the lower bound of the range of journal articles
4955            * @param end the upper bound of the range of journal articles (not inclusive)
4956            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4957            * @return the ordered range of matching journal articles
4958            */
4959            public static List<JournalArticle> findByR_I_S(long resourcePrimKey,
4960                    boolean indexable, int[] statuses, int start, int end,
4961                    OrderByComparator<JournalArticle> orderByComparator) {
4962                    return getPersistence()
4963                                       .findByR_I_S(resourcePrimKey, indexable, statuses, start,
4964                            end, orderByComparator);
4965            }
4966    
4967            /**
4968            * Removes all the journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63; from the database.
4969            *
4970            * @param resourcePrimKey the resource prim key
4971            * @param indexable the indexable
4972            * @param status the status
4973            */
4974            public static void removeByR_I_S(long resourcePrimKey, boolean indexable,
4975                    int status) {
4976                    getPersistence().removeByR_I_S(resourcePrimKey, indexable, status);
4977            }
4978    
4979            /**
4980            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = &#63;.
4981            *
4982            * @param resourcePrimKey the resource prim key
4983            * @param indexable the indexable
4984            * @param status the status
4985            * @return the number of matching journal articles
4986            */
4987            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
4988                    int status) {
4989                    return getPersistence().countByR_I_S(resourcePrimKey, indexable, status);
4990            }
4991    
4992            /**
4993            * Returns the number of journal articles where resourcePrimKey = &#63; and indexable = &#63; and status = any &#63;.
4994            *
4995            * @param resourcePrimKey the resource prim key
4996            * @param indexable the indexable
4997            * @param statuses the statuses
4998            * @return the number of matching journal articles
4999            */
5000            public static int countByR_I_S(long resourcePrimKey, boolean indexable,
5001                    int[] statuses) {
5002                    return getPersistence()
5003                                       .countByR_I_S(resourcePrimKey, indexable, statuses);
5004            }
5005    
5006            /**
5007            * Returns all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5008            *
5009            * @param groupId the group ID
5010            * @param userId the user ID
5011            * @param classNameId the class name ID
5012            * @return the matching journal articles
5013            */
5014            public static List<JournalArticle> findByG_U_C(long groupId, long userId,
5015                    long classNameId) {
5016                    return getPersistence().findByG_U_C(groupId, userId, classNameId);
5017            }
5018    
5019            /**
5020            * Returns a range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5021            *
5022            * <p>
5023            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5024            * </p>
5025            *
5026            * @param groupId the group ID
5027            * @param userId the user ID
5028            * @param classNameId the class name ID
5029            * @param start the lower bound of the range of journal articles
5030            * @param end the upper bound of the range of journal articles (not inclusive)
5031            * @return the range of matching journal articles
5032            */
5033            public static List<JournalArticle> findByG_U_C(long groupId, long userId,
5034                    long classNameId, int start, int end) {
5035                    return getPersistence()
5036                                       .findByG_U_C(groupId, userId, classNameId, start, end);
5037            }
5038    
5039            /**
5040            * Returns an ordered range of all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5041            *
5042            * <p>
5043            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5044            * </p>
5045            *
5046            * @param groupId the group ID
5047            * @param userId the user ID
5048            * @param classNameId the class name ID
5049            * @param start the lower bound of the range of journal articles
5050            * @param end the upper bound of the range of journal articles (not inclusive)
5051            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5052            * @return the ordered range of matching journal articles
5053            */
5054            public static List<JournalArticle> findByG_U_C(long groupId, long userId,
5055                    long classNameId, int start, int end,
5056                    OrderByComparator<JournalArticle> orderByComparator) {
5057                    return getPersistence()
5058                                       .findByG_U_C(groupId, userId, classNameId, start, end,
5059                            orderByComparator);
5060            }
5061    
5062            /**
5063            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5064            *
5065            * @param groupId the group ID
5066            * @param userId the user ID
5067            * @param classNameId the class name ID
5068            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5069            * @return the first matching journal article
5070            * @throws NoSuchArticleException if a matching journal article could not be found
5071            */
5072            public static JournalArticle findByG_U_C_First(long groupId, long userId,
5073                    long classNameId, OrderByComparator<JournalArticle> orderByComparator)
5074                    throws com.liferay.portlet.journal.NoSuchArticleException {
5075                    return getPersistence()
5076                                       .findByG_U_C_First(groupId, userId, classNameId,
5077                            orderByComparator);
5078            }
5079    
5080            /**
5081            * Returns the first journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5082            *
5083            * @param groupId the group ID
5084            * @param userId the user ID
5085            * @param classNameId the class name ID
5086            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5087            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5088            */
5089            public static JournalArticle fetchByG_U_C_First(long groupId, long userId,
5090                    long classNameId, OrderByComparator<JournalArticle> orderByComparator) {
5091                    return getPersistence()
5092                                       .fetchByG_U_C_First(groupId, userId, classNameId,
5093                            orderByComparator);
5094            }
5095    
5096            /**
5097            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5098            *
5099            * @param groupId the group ID
5100            * @param userId the user ID
5101            * @param classNameId the class name ID
5102            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5103            * @return the last matching journal article
5104            * @throws NoSuchArticleException if a matching journal article could not be found
5105            */
5106            public static JournalArticle findByG_U_C_Last(long groupId, long userId,
5107                    long classNameId, OrderByComparator<JournalArticle> orderByComparator)
5108                    throws com.liferay.portlet.journal.NoSuchArticleException {
5109                    return getPersistence()
5110                                       .findByG_U_C_Last(groupId, userId, classNameId,
5111                            orderByComparator);
5112            }
5113    
5114            /**
5115            * Returns the last journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5116            *
5117            * @param groupId the group ID
5118            * @param userId the user ID
5119            * @param classNameId the class name ID
5120            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5121            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5122            */
5123            public static JournalArticle fetchByG_U_C_Last(long groupId, long userId,
5124                    long classNameId, OrderByComparator<JournalArticle> orderByComparator) {
5125                    return getPersistence()
5126                                       .fetchByG_U_C_Last(groupId, userId, classNameId,
5127                            orderByComparator);
5128            }
5129    
5130            /**
5131            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5132            *
5133            * @param id the primary key of the current journal article
5134            * @param groupId the group ID
5135            * @param userId the user ID
5136            * @param classNameId the class name ID
5137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5138            * @return the previous, current, and next journal article
5139            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5140            */
5141            public static JournalArticle[] findByG_U_C_PrevAndNext(long id,
5142                    long groupId, long userId, long classNameId,
5143                    OrderByComparator<JournalArticle> orderByComparator)
5144                    throws com.liferay.portlet.journal.NoSuchArticleException {
5145                    return getPersistence()
5146                                       .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId,
5147                            orderByComparator);
5148            }
5149    
5150            /**
5151            * Returns all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5152            *
5153            * @param groupId the group ID
5154            * @param userId the user ID
5155            * @param classNameId the class name ID
5156            * @return the matching journal articles that the user has permission to view
5157            */
5158            public static List<JournalArticle> filterFindByG_U_C(long groupId,
5159                    long userId, long classNameId) {
5160                    return getPersistence().filterFindByG_U_C(groupId, userId, classNameId);
5161            }
5162    
5163            /**
5164            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5165            *
5166            * <p>
5167            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5168            * </p>
5169            *
5170            * @param groupId the group ID
5171            * @param userId the user ID
5172            * @param classNameId the class name ID
5173            * @param start the lower bound of the range of journal articles
5174            * @param end the upper bound of the range of journal articles (not inclusive)
5175            * @return the range of matching journal articles that the user has permission to view
5176            */
5177            public static List<JournalArticle> filterFindByG_U_C(long groupId,
5178                    long userId, long classNameId, int start, int end) {
5179                    return getPersistence()
5180                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end);
5181            }
5182    
5183            /**
5184            * 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;.
5185            *
5186            * <p>
5187            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5188            * </p>
5189            *
5190            * @param groupId the group ID
5191            * @param userId the user ID
5192            * @param classNameId the class name ID
5193            * @param start the lower bound of the range of journal articles
5194            * @param end the upper bound of the range of journal articles (not inclusive)
5195            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5196            * @return the ordered range of matching journal articles that the user has permission to view
5197            */
5198            public static List<JournalArticle> filterFindByG_U_C(long groupId,
5199                    long userId, long classNameId, int start, int end,
5200                    OrderByComparator<JournalArticle> orderByComparator) {
5201                    return getPersistence()
5202                                       .filterFindByG_U_C(groupId, userId, classNameId, start, end,
5203                            orderByComparator);
5204            }
5205    
5206            /**
5207            * 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;.
5208            *
5209            * @param id the primary key of the current journal article
5210            * @param groupId the group ID
5211            * @param userId the user ID
5212            * @param classNameId the class name ID
5213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5214            * @return the previous, current, and next journal article
5215            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5216            */
5217            public static JournalArticle[] filterFindByG_U_C_PrevAndNext(long id,
5218                    long groupId, long userId, long classNameId,
5219                    OrderByComparator<JournalArticle> orderByComparator)
5220                    throws com.liferay.portlet.journal.NoSuchArticleException {
5221                    return getPersistence()
5222                                       .filterFindByG_U_C_PrevAndNext(id, groupId, userId,
5223                            classNameId, orderByComparator);
5224            }
5225    
5226            /**
5227            * Removes all the journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63; from the database.
5228            *
5229            * @param groupId the group ID
5230            * @param userId the user ID
5231            * @param classNameId the class name ID
5232            */
5233            public static void removeByG_U_C(long groupId, long userId, long classNameId) {
5234                    getPersistence().removeByG_U_C(groupId, userId, classNameId);
5235            }
5236    
5237            /**
5238            * Returns the number of journal articles where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5239            *
5240            * @param groupId the group ID
5241            * @param userId the user ID
5242            * @param classNameId the class name ID
5243            * @return the number of matching journal articles
5244            */
5245            public static int countByG_U_C(long groupId, long userId, long classNameId) {
5246                    return getPersistence().countByG_U_C(groupId, userId, classNameId);
5247            }
5248    
5249            /**
5250            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and userId = &#63; and classNameId = &#63;.
5251            *
5252            * @param groupId the group ID
5253            * @param userId the user ID
5254            * @param classNameId the class name ID
5255            * @return the number of matching journal articles that the user has permission to view
5256            */
5257            public static int filterCountByG_U_C(long groupId, long userId,
5258                    long classNameId) {
5259                    return getPersistence().filterCountByG_U_C(groupId, userId, classNameId);
5260            }
5261    
5262            /**
5263            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5264            *
5265            * @param groupId the group ID
5266            * @param folderId the folder ID
5267            * @param status the status
5268            * @return the matching journal articles
5269            */
5270            public static List<JournalArticle> findByG_F_ST(long groupId,
5271                    long folderId, int status) {
5272                    return getPersistence().findByG_F_ST(groupId, folderId, status);
5273            }
5274    
5275            /**
5276            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5277            *
5278            * <p>
5279            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5280            * </p>
5281            *
5282            * @param groupId the group ID
5283            * @param folderId the folder ID
5284            * @param status the status
5285            * @param start the lower bound of the range of journal articles
5286            * @param end the upper bound of the range of journal articles (not inclusive)
5287            * @return the range of matching journal articles
5288            */
5289            public static List<JournalArticle> findByG_F_ST(long groupId,
5290                    long folderId, int status, int start, int end) {
5291                    return getPersistence()
5292                                       .findByG_F_ST(groupId, folderId, status, start, end);
5293            }
5294    
5295            /**
5296            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5297            *
5298            * <p>
5299            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5300            * </p>
5301            *
5302            * @param groupId the group ID
5303            * @param folderId the folder ID
5304            * @param status the status
5305            * @param start the lower bound of the range of journal articles
5306            * @param end the upper bound of the range of journal articles (not inclusive)
5307            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5308            * @return the ordered range of matching journal articles
5309            */
5310            public static List<JournalArticle> findByG_F_ST(long groupId,
5311                    long folderId, int status, int start, int end,
5312                    OrderByComparator<JournalArticle> orderByComparator) {
5313                    return getPersistence()
5314                                       .findByG_F_ST(groupId, folderId, status, start, end,
5315                            orderByComparator);
5316            }
5317    
5318            /**
5319            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5320            *
5321            * @param groupId the group ID
5322            * @param folderId the folder ID
5323            * @param status the status
5324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5325            * @return the first matching journal article
5326            * @throws NoSuchArticleException if a matching journal article could not be found
5327            */
5328            public static JournalArticle findByG_F_ST_First(long groupId,
5329                    long folderId, int status,
5330                    OrderByComparator<JournalArticle> orderByComparator)
5331                    throws com.liferay.portlet.journal.NoSuchArticleException {
5332                    return getPersistence()
5333                                       .findByG_F_ST_First(groupId, folderId, status,
5334                            orderByComparator);
5335            }
5336    
5337            /**
5338            * Returns the first journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5339            *
5340            * @param groupId the group ID
5341            * @param folderId the folder ID
5342            * @param status the status
5343            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5344            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5345            */
5346            public static JournalArticle fetchByG_F_ST_First(long groupId,
5347                    long folderId, int status,
5348                    OrderByComparator<JournalArticle> orderByComparator) {
5349                    return getPersistence()
5350                                       .fetchByG_F_ST_First(groupId, folderId, status,
5351                            orderByComparator);
5352            }
5353    
5354            /**
5355            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5356            *
5357            * @param groupId the group ID
5358            * @param folderId the folder ID
5359            * @param status the status
5360            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5361            * @return the last matching journal article
5362            * @throws NoSuchArticleException if a matching journal article could not be found
5363            */
5364            public static JournalArticle findByG_F_ST_Last(long groupId, long folderId,
5365                    int status, OrderByComparator<JournalArticle> orderByComparator)
5366                    throws com.liferay.portlet.journal.NoSuchArticleException {
5367                    return getPersistence()
5368                                       .findByG_F_ST_Last(groupId, folderId, status,
5369                            orderByComparator);
5370            }
5371    
5372            /**
5373            * Returns the last journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5374            *
5375            * @param groupId the group ID
5376            * @param folderId the folder ID
5377            * @param status the status
5378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5379            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5380            */
5381            public static JournalArticle fetchByG_F_ST_Last(long groupId,
5382                    long folderId, int status,
5383                    OrderByComparator<JournalArticle> orderByComparator) {
5384                    return getPersistence()
5385                                       .fetchByG_F_ST_Last(groupId, folderId, status,
5386                            orderByComparator);
5387            }
5388    
5389            /**
5390            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
5391            *
5392            * @param id the primary key of the current journal article
5393            * @param groupId the group ID
5394            * @param folderId the folder ID
5395            * @param status the status
5396            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5397            * @return the previous, current, and next journal article
5398            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5399            */
5400            public static JournalArticle[] findByG_F_ST_PrevAndNext(long id,
5401                    long groupId, long folderId, int status,
5402                    OrderByComparator<JournalArticle> orderByComparator)
5403                    throws com.liferay.portlet.journal.NoSuchArticleException {
5404                    return getPersistence()
5405                                       .findByG_F_ST_PrevAndNext(id, groupId, folderId, status,
5406                            orderByComparator);
5407            }
5408    
5409            /**
5410            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5411            *
5412            * @param groupId the group ID
5413            * @param folderId the folder ID
5414            * @param status the status
5415            * @return the matching journal articles that the user has permission to view
5416            */
5417            public static List<JournalArticle> filterFindByG_F_ST(long groupId,
5418                    long folderId, int status) {
5419                    return getPersistence().filterFindByG_F_ST(groupId, folderId, status);
5420            }
5421    
5422            /**
5423            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5424            *
5425            * <p>
5426            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5427            * </p>
5428            *
5429            * @param groupId the group ID
5430            * @param folderId the folder ID
5431            * @param status the status
5432            * @param start the lower bound of the range of journal articles
5433            * @param end the upper bound of the range of journal articles (not inclusive)
5434            * @return the range of matching journal articles that the user has permission to view
5435            */
5436            public static List<JournalArticle> filterFindByG_F_ST(long groupId,
5437                    long folderId, int status, int start, int end) {
5438                    return getPersistence()
5439                                       .filterFindByG_F_ST(groupId, folderId, status, start, end);
5440            }
5441    
5442            /**
5443            * 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;.
5444            *
5445            * <p>
5446            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5447            * </p>
5448            *
5449            * @param groupId the group ID
5450            * @param folderId the folder ID
5451            * @param status the status
5452            * @param start the lower bound of the range of journal articles
5453            * @param end the upper bound of the range of journal articles (not inclusive)
5454            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5455            * @return the ordered range of matching journal articles that the user has permission to view
5456            */
5457            public static List<JournalArticle> filterFindByG_F_ST(long groupId,
5458                    long folderId, int status, int start, int end,
5459                    OrderByComparator<JournalArticle> orderByComparator) {
5460                    return getPersistence()
5461                                       .filterFindByG_F_ST(groupId, folderId, status, start, end,
5462                            orderByComparator);
5463            }
5464    
5465            /**
5466            * 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;.
5467            *
5468            * @param id the primary key of the current journal article
5469            * @param groupId the group ID
5470            * @param folderId the folder ID
5471            * @param status the status
5472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5473            * @return the previous, current, and next journal article
5474            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5475            */
5476            public static JournalArticle[] filterFindByG_F_ST_PrevAndNext(long id,
5477                    long groupId, long folderId, int status,
5478                    OrderByComparator<JournalArticle> orderByComparator)
5479                    throws com.liferay.portlet.journal.NoSuchArticleException {
5480                    return getPersistence()
5481                                       .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId,
5482                            status, orderByComparator);
5483            }
5484    
5485            /**
5486            * Returns all the journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5487            *
5488            * @param groupId the group ID
5489            * @param folderId the folder ID
5490            * @param statuses the statuses
5491            * @return the matching journal articles that the user has permission to view
5492            */
5493            public static List<JournalArticle> filterFindByG_F_ST(long groupId,
5494                    long folderId, int[] statuses) {
5495                    return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses);
5496            }
5497    
5498            /**
5499            * 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;.
5500            *
5501            * <p>
5502            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5503            * </p>
5504            *
5505            * @param groupId the group ID
5506            * @param folderId the folder ID
5507            * @param statuses the statuses
5508            * @param start the lower bound of the range of journal articles
5509            * @param end the upper bound of the range of journal articles (not inclusive)
5510            * @return the range of matching journal articles that the user has permission to view
5511            */
5512            public static List<JournalArticle> filterFindByG_F_ST(long groupId,
5513                    long folderId, int[] statuses, int start, int end) {
5514                    return getPersistence()
5515                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end);
5516            }
5517    
5518            /**
5519            * 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;.
5520            *
5521            * <p>
5522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5523            * </p>
5524            *
5525            * @param groupId the group ID
5526            * @param folderId the folder ID
5527            * @param statuses the statuses
5528            * @param start the lower bound of the range of journal articles
5529            * @param end the upper bound of the range of journal articles (not inclusive)
5530            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5531            * @return the ordered range of matching journal articles that the user has permission to view
5532            */
5533            public static List<JournalArticle> filterFindByG_F_ST(long groupId,
5534                    long folderId, int[] statuses, int start, int end,
5535                    OrderByComparator<JournalArticle> orderByComparator) {
5536                    return getPersistence()
5537                                       .filterFindByG_F_ST(groupId, folderId, statuses, start, end,
5538                            orderByComparator);
5539            }
5540    
5541            /**
5542            * Returns all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5543            *
5544            * <p>
5545            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5546            * </p>
5547            *
5548            * @param groupId the group ID
5549            * @param folderId the folder ID
5550            * @param statuses the statuses
5551            * @return the matching journal articles
5552            */
5553            public static List<JournalArticle> findByG_F_ST(long groupId,
5554                    long folderId, int[] statuses) {
5555                    return getPersistence().findByG_F_ST(groupId, folderId, statuses);
5556            }
5557    
5558            /**
5559            * Returns a range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5560            *
5561            * <p>
5562            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5563            * </p>
5564            *
5565            * @param groupId the group ID
5566            * @param folderId the folder ID
5567            * @param statuses the statuses
5568            * @param start the lower bound of the range of journal articles
5569            * @param end the upper bound of the range of journal articles (not inclusive)
5570            * @return the range of matching journal articles
5571            */
5572            public static List<JournalArticle> findByG_F_ST(long groupId,
5573                    long folderId, int[] statuses, int start, int end) {
5574                    return getPersistence()
5575                                       .findByG_F_ST(groupId, folderId, statuses, start, end);
5576            }
5577    
5578            /**
5579            * Returns an ordered range of all the journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5580            *
5581            * <p>
5582            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5583            * </p>
5584            *
5585            * @param groupId the group ID
5586            * @param folderId the folder ID
5587            * @param statuses the statuses
5588            * @param start the lower bound of the range of journal articles
5589            * @param end the upper bound of the range of journal articles (not inclusive)
5590            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5591            * @return the ordered range of matching journal articles
5592            */
5593            public static List<JournalArticle> findByG_F_ST(long groupId,
5594                    long folderId, int[] statuses, int start, int end,
5595                    OrderByComparator<JournalArticle> orderByComparator) {
5596                    return getPersistence()
5597                                       .findByG_F_ST(groupId, folderId, statuses, start, end,
5598                            orderByComparator);
5599            }
5600    
5601            /**
5602            * Removes all the journal articles where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
5603            *
5604            * @param groupId the group ID
5605            * @param folderId the folder ID
5606            * @param status the status
5607            */
5608            public static void removeByG_F_ST(long groupId, long folderId, int status) {
5609                    getPersistence().removeByG_F_ST(groupId, folderId, status);
5610            }
5611    
5612            /**
5613            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = &#63;.
5614            *
5615            * @param groupId the group ID
5616            * @param folderId the folder ID
5617            * @param status the status
5618            * @return the number of matching journal articles
5619            */
5620            public static int countByG_F_ST(long groupId, long folderId, int status) {
5621                    return getPersistence().countByG_F_ST(groupId, folderId, status);
5622            }
5623    
5624            /**
5625            * Returns the number of journal articles where groupId = &#63; and folderId = &#63; and status = any &#63;.
5626            *
5627            * @param groupId the group ID
5628            * @param folderId the folder ID
5629            * @param statuses the statuses
5630            * @return the number of matching journal articles
5631            */
5632            public static int countByG_F_ST(long groupId, long folderId, int[] statuses) {
5633                    return getPersistence().countByG_F_ST(groupId, folderId, statuses);
5634            }
5635    
5636            /**
5637            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
5638            *
5639            * @param groupId the group ID
5640            * @param folderId the folder ID
5641            * @param status the status
5642            * @return the number of matching journal articles that the user has permission to view
5643            */
5644            public static int filterCountByG_F_ST(long groupId, long folderId,
5645                    int status) {
5646                    return getPersistence().filterCountByG_F_ST(groupId, folderId, status);
5647            }
5648    
5649            /**
5650            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and folderId = &#63; and status = any &#63;.
5651            *
5652            * @param groupId the group ID
5653            * @param folderId the folder ID
5654            * @param statuses the statuses
5655            * @return the number of matching journal articles that the user has permission to view
5656            */
5657            public static int filterCountByG_F_ST(long groupId, long folderId,
5658                    int[] statuses) {
5659                    return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses);
5660            }
5661    
5662            /**
5663            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5664            *
5665            * @param groupId the group ID
5666            * @param classNameId the class name ID
5667            * @param classPK the class p k
5668            * @return the matching journal articles
5669            */
5670            public static List<JournalArticle> findByG_C_C(long groupId,
5671                    long classNameId, long classPK) {
5672                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
5673            }
5674    
5675            /**
5676            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5677            *
5678            * <p>
5679            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5680            * </p>
5681            *
5682            * @param groupId the group ID
5683            * @param classNameId the class name ID
5684            * @param classPK the class p k
5685            * @param start the lower bound of the range of journal articles
5686            * @param end the upper bound of the range of journal articles (not inclusive)
5687            * @return the range of matching journal articles
5688            */
5689            public static List<JournalArticle> findByG_C_C(long groupId,
5690                    long classNameId, long classPK, int start, int end) {
5691                    return getPersistence()
5692                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
5693            }
5694    
5695            /**
5696            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5697            *
5698            * <p>
5699            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5700            * </p>
5701            *
5702            * @param groupId the group ID
5703            * @param classNameId the class name ID
5704            * @param classPK the class p k
5705            * @param start the lower bound of the range of journal articles
5706            * @param end the upper bound of the range of journal articles (not inclusive)
5707            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5708            * @return the ordered range of matching journal articles
5709            */
5710            public static List<JournalArticle> findByG_C_C(long groupId,
5711                    long classNameId, long classPK, int start, int end,
5712                    OrderByComparator<JournalArticle> orderByComparator) {
5713                    return getPersistence()
5714                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
5715                            orderByComparator);
5716            }
5717    
5718            /**
5719            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5720            *
5721            * @param groupId the group ID
5722            * @param classNameId the class name ID
5723            * @param classPK the class p k
5724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5725            * @return the first matching journal article
5726            * @throws NoSuchArticleException if a matching journal article could not be found
5727            */
5728            public static JournalArticle findByG_C_C_First(long groupId,
5729                    long classNameId, long classPK,
5730                    OrderByComparator<JournalArticle> orderByComparator)
5731                    throws com.liferay.portlet.journal.NoSuchArticleException {
5732                    return getPersistence()
5733                                       .findByG_C_C_First(groupId, classNameId, classPK,
5734                            orderByComparator);
5735            }
5736    
5737            /**
5738            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5739            *
5740            * @param groupId the group ID
5741            * @param classNameId the class name ID
5742            * @param classPK the class p k
5743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5744            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
5745            */
5746            public static JournalArticle fetchByG_C_C_First(long groupId,
5747                    long classNameId, long classPK,
5748                    OrderByComparator<JournalArticle> orderByComparator) {
5749                    return getPersistence()
5750                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
5751                            orderByComparator);
5752            }
5753    
5754            /**
5755            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5756            *
5757            * @param groupId the group ID
5758            * @param classNameId the class name ID
5759            * @param classPK the class p k
5760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5761            * @return the last matching journal article
5762            * @throws NoSuchArticleException if a matching journal article could not be found
5763            */
5764            public static JournalArticle findByG_C_C_Last(long groupId,
5765                    long classNameId, long classPK,
5766                    OrderByComparator<JournalArticle> orderByComparator)
5767                    throws com.liferay.portlet.journal.NoSuchArticleException {
5768                    return getPersistence()
5769                                       .findByG_C_C_Last(groupId, classNameId, classPK,
5770                            orderByComparator);
5771            }
5772    
5773            /**
5774            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5775            *
5776            * @param groupId the group ID
5777            * @param classNameId the class name ID
5778            * @param classPK the class p k
5779            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5780            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
5781            */
5782            public static JournalArticle fetchByG_C_C_Last(long groupId,
5783                    long classNameId, long classPK,
5784                    OrderByComparator<JournalArticle> orderByComparator) {
5785                    return getPersistence()
5786                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
5787                            orderByComparator);
5788            }
5789    
5790            /**
5791            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5792            *
5793            * @param id the primary key of the current journal article
5794            * @param groupId the group ID
5795            * @param classNameId the class name ID
5796            * @param classPK the class p k
5797            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5798            * @return the previous, current, and next journal article
5799            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5800            */
5801            public static JournalArticle[] findByG_C_C_PrevAndNext(long id,
5802                    long groupId, long classNameId, long classPK,
5803                    OrderByComparator<JournalArticle> orderByComparator)
5804                    throws com.liferay.portlet.journal.NoSuchArticleException {
5805                    return getPersistence()
5806                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
5807                            orderByComparator);
5808            }
5809    
5810            /**
5811            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5812            *
5813            * @param groupId the group ID
5814            * @param classNameId the class name ID
5815            * @param classPK the class p k
5816            * @return the matching journal articles that the user has permission to view
5817            */
5818            public static List<JournalArticle> filterFindByG_C_C(long groupId,
5819                    long classNameId, long classPK) {
5820                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
5821            }
5822    
5823            /**
5824            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5825            *
5826            * <p>
5827            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5828            * </p>
5829            *
5830            * @param groupId the group ID
5831            * @param classNameId the class name ID
5832            * @param classPK the class p k
5833            * @param start the lower bound of the range of journal articles
5834            * @param end the upper bound of the range of journal articles (not inclusive)
5835            * @return the range of matching journal articles that the user has permission to view
5836            */
5837            public static List<JournalArticle> filterFindByG_C_C(long groupId,
5838                    long classNameId, long classPK, int start, int end) {
5839                    return getPersistence()
5840                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
5841            }
5842    
5843            /**
5844            * 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;.
5845            *
5846            * <p>
5847            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
5848            * </p>
5849            *
5850            * @param groupId the group ID
5851            * @param classNameId the class name ID
5852            * @param classPK the class p k
5853            * @param start the lower bound of the range of journal articles
5854            * @param end the upper bound of the range of journal articles (not inclusive)
5855            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5856            * @return the ordered range of matching journal articles that the user has permission to view
5857            */
5858            public static List<JournalArticle> filterFindByG_C_C(long groupId,
5859                    long classNameId, long classPK, int start, int end,
5860                    OrderByComparator<JournalArticle> orderByComparator) {
5861                    return getPersistence()
5862                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
5863                            end, orderByComparator);
5864            }
5865    
5866            /**
5867            * 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;.
5868            *
5869            * @param id the primary key of the current journal article
5870            * @param groupId the group ID
5871            * @param classNameId the class name ID
5872            * @param classPK the class p k
5873            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5874            * @return the previous, current, and next journal article
5875            * @throws NoSuchArticleException if a journal article with the primary key could not be found
5876            */
5877            public static JournalArticle[] filterFindByG_C_C_PrevAndNext(long id,
5878                    long groupId, long classNameId, long classPK,
5879                    OrderByComparator<JournalArticle> orderByComparator)
5880                    throws com.liferay.portlet.journal.NoSuchArticleException {
5881                    return getPersistence()
5882                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
5883                            classPK, orderByComparator);
5884            }
5885    
5886            /**
5887            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
5888            *
5889            * @param groupId the group ID
5890            * @param classNameId the class name ID
5891            * @param classPK the class p k
5892            */
5893            public static void removeByG_C_C(long groupId, long classNameId,
5894                    long classPK) {
5895                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
5896            }
5897    
5898            /**
5899            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5900            *
5901            * @param groupId the group ID
5902            * @param classNameId the class name ID
5903            * @param classPK the class p k
5904            * @return the number of matching journal articles
5905            */
5906            public static int countByG_C_C(long groupId, long classNameId, long classPK) {
5907                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
5908            }
5909    
5910            /**
5911            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
5912            *
5913            * @param groupId the group ID
5914            * @param classNameId the class name ID
5915            * @param classPK the class p k
5916            * @return the number of matching journal articles that the user has permission to view
5917            */
5918            public static int filterCountByG_C_C(long groupId, long classNameId,
5919                    long classPK) {
5920                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
5921            }
5922    
5923            /**
5924            * Returns the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; or throws a {@link NoSuchArticleException} if it could not be found.
5925            *
5926            * @param groupId the group ID
5927            * @param classNameId the class name ID
5928            * @param DDMStructureKey the d d m structure key
5929            * @return the matching journal article
5930            * @throws NoSuchArticleException if a matching journal article could not be found
5931            */
5932            public static JournalArticle findByG_C_DDMSK(long groupId,
5933                    long classNameId, java.lang.String DDMStructureKey)
5934                    throws com.liferay.portlet.journal.NoSuchArticleException {
5935                    return getPersistence()
5936                                       .findByG_C_DDMSK(groupId, classNameId, DDMStructureKey);
5937            }
5938    
5939            /**
5940            * Returns the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
5941            *
5942            * @param groupId the group ID
5943            * @param classNameId the class name ID
5944            * @param DDMStructureKey the d d m structure key
5945            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5946            */
5947            public static JournalArticle fetchByG_C_DDMSK(long groupId,
5948                    long classNameId, java.lang.String DDMStructureKey) {
5949                    return getPersistence()
5950                                       .fetchByG_C_DDMSK(groupId, classNameId, DDMStructureKey);
5951            }
5952    
5953            /**
5954            * Returns the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
5955            *
5956            * @param groupId the group ID
5957            * @param classNameId the class name ID
5958            * @param DDMStructureKey the d d m structure key
5959            * @param retrieveFromCache whether to use the finder cache
5960            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
5961            */
5962            public static JournalArticle fetchByG_C_DDMSK(long groupId,
5963                    long classNameId, java.lang.String DDMStructureKey,
5964                    boolean retrieveFromCache) {
5965                    return getPersistence()
5966                                       .fetchByG_C_DDMSK(groupId, classNameId, DDMStructureKey,
5967                            retrieveFromCache);
5968            }
5969    
5970            /**
5971            * Removes the journal article where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63; from the database.
5972            *
5973            * @param groupId the group ID
5974            * @param classNameId the class name ID
5975            * @param DDMStructureKey the d d m structure key
5976            * @return the journal article that was removed
5977            */
5978            public static JournalArticle removeByG_C_DDMSK(long groupId,
5979                    long classNameId, java.lang.String DDMStructureKey)
5980                    throws com.liferay.portlet.journal.NoSuchArticleException {
5981                    return getPersistence()
5982                                       .removeByG_C_DDMSK(groupId, classNameId, DDMStructureKey);
5983            }
5984    
5985            /**
5986            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and DDMStructureKey = &#63;.
5987            *
5988            * @param groupId the group ID
5989            * @param classNameId the class name ID
5990            * @param DDMStructureKey the d d m structure key
5991            * @return the number of matching journal articles
5992            */
5993            public static int countByG_C_DDMSK(long groupId, long classNameId,
5994                    java.lang.String DDMStructureKey) {
5995                    return getPersistence()
5996                                       .countByG_C_DDMSK(groupId, classNameId, DDMStructureKey);
5997            }
5998    
5999            /**
6000            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6001            *
6002            * @param groupId the group ID
6003            * @param classNameId the class name ID
6004            * @param DDMTemplateKey the d d m template key
6005            * @return the matching journal articles
6006            */
6007            public static List<JournalArticle> findByG_C_DDMTK(long groupId,
6008                    long classNameId, java.lang.String DDMTemplateKey) {
6009                    return getPersistence()
6010                                       .findByG_C_DDMTK(groupId, classNameId, DDMTemplateKey);
6011            }
6012    
6013            /**
6014            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6015            *
6016            * <p>
6017            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6018            * </p>
6019            *
6020            * @param groupId the group ID
6021            * @param classNameId the class name ID
6022            * @param DDMTemplateKey the d d m template key
6023            * @param start the lower bound of the range of journal articles
6024            * @param end the upper bound of the range of journal articles (not inclusive)
6025            * @return the range of matching journal articles
6026            */
6027            public static List<JournalArticle> findByG_C_DDMTK(long groupId,
6028                    long classNameId, java.lang.String DDMTemplateKey, int start, int end) {
6029                    return getPersistence()
6030                                       .findByG_C_DDMTK(groupId, classNameId, DDMTemplateKey,
6031                            start, end);
6032            }
6033    
6034            /**
6035            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6036            *
6037            * <p>
6038            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6039            * </p>
6040            *
6041            * @param groupId the group ID
6042            * @param classNameId the class name ID
6043            * @param DDMTemplateKey the d d m template key
6044            * @param start the lower bound of the range of journal articles
6045            * @param end the upper bound of the range of journal articles (not inclusive)
6046            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6047            * @return the ordered range of matching journal articles
6048            */
6049            public static List<JournalArticle> findByG_C_DDMTK(long groupId,
6050                    long classNameId, java.lang.String DDMTemplateKey, int start, int end,
6051                    OrderByComparator<JournalArticle> orderByComparator) {
6052                    return getPersistence()
6053                                       .findByG_C_DDMTK(groupId, classNameId, DDMTemplateKey,
6054                            start, end, orderByComparator);
6055            }
6056    
6057            /**
6058            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6059            *
6060            * @param groupId the group ID
6061            * @param classNameId the class name ID
6062            * @param DDMTemplateKey the d d m template key
6063            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6064            * @return the first matching journal article
6065            * @throws NoSuchArticleException if a matching journal article could not be found
6066            */
6067            public static JournalArticle findByG_C_DDMTK_First(long groupId,
6068                    long classNameId, java.lang.String DDMTemplateKey,
6069                    OrderByComparator<JournalArticle> orderByComparator)
6070                    throws com.liferay.portlet.journal.NoSuchArticleException {
6071                    return getPersistence()
6072                                       .findByG_C_DDMTK_First(groupId, classNameId, DDMTemplateKey,
6073                            orderByComparator);
6074            }
6075    
6076            /**
6077            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6078            *
6079            * @param groupId the group ID
6080            * @param classNameId the class name ID
6081            * @param DDMTemplateKey the d d m template key
6082            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6083            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6084            */
6085            public static JournalArticle fetchByG_C_DDMTK_First(long groupId,
6086                    long classNameId, java.lang.String DDMTemplateKey,
6087                    OrderByComparator<JournalArticle> orderByComparator) {
6088                    return getPersistence()
6089                                       .fetchByG_C_DDMTK_First(groupId, classNameId,
6090                            DDMTemplateKey, orderByComparator);
6091            }
6092    
6093            /**
6094            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6095            *
6096            * @param groupId the group ID
6097            * @param classNameId the class name ID
6098            * @param DDMTemplateKey the d d m template key
6099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6100            * @return the last matching journal article
6101            * @throws NoSuchArticleException if a matching journal article could not be found
6102            */
6103            public static JournalArticle findByG_C_DDMTK_Last(long groupId,
6104                    long classNameId, java.lang.String DDMTemplateKey,
6105                    OrderByComparator<JournalArticle> orderByComparator)
6106                    throws com.liferay.portlet.journal.NoSuchArticleException {
6107                    return getPersistence()
6108                                       .findByG_C_DDMTK_Last(groupId, classNameId, DDMTemplateKey,
6109                            orderByComparator);
6110            }
6111    
6112            /**
6113            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6114            *
6115            * @param groupId the group ID
6116            * @param classNameId the class name ID
6117            * @param DDMTemplateKey the d d m template key
6118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6119            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6120            */
6121            public static JournalArticle fetchByG_C_DDMTK_Last(long groupId,
6122                    long classNameId, java.lang.String DDMTemplateKey,
6123                    OrderByComparator<JournalArticle> orderByComparator) {
6124                    return getPersistence()
6125                                       .fetchByG_C_DDMTK_Last(groupId, classNameId, DDMTemplateKey,
6126                            orderByComparator);
6127            }
6128    
6129            /**
6130            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6131            *
6132            * @param id the primary key of the current journal article
6133            * @param groupId the group ID
6134            * @param classNameId the class name ID
6135            * @param DDMTemplateKey the d d m template key
6136            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6137            * @return the previous, current, and next journal article
6138            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6139            */
6140            public static JournalArticle[] findByG_C_DDMTK_PrevAndNext(long id,
6141                    long groupId, long classNameId, java.lang.String DDMTemplateKey,
6142                    OrderByComparator<JournalArticle> orderByComparator)
6143                    throws com.liferay.portlet.journal.NoSuchArticleException {
6144                    return getPersistence()
6145                                       .findByG_C_DDMTK_PrevAndNext(id, groupId, classNameId,
6146                            DDMTemplateKey, orderByComparator);
6147            }
6148    
6149            /**
6150            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6151            *
6152            * @param groupId the group ID
6153            * @param classNameId the class name ID
6154            * @param DDMTemplateKey the d d m template key
6155            * @return the matching journal articles that the user has permission to view
6156            */
6157            public static List<JournalArticle> filterFindByG_C_DDMTK(long groupId,
6158                    long classNameId, java.lang.String DDMTemplateKey) {
6159                    return getPersistence()
6160                                       .filterFindByG_C_DDMTK(groupId, classNameId, DDMTemplateKey);
6161            }
6162    
6163            /**
6164            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6165            *
6166            * <p>
6167            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6168            * </p>
6169            *
6170            * @param groupId the group ID
6171            * @param classNameId the class name ID
6172            * @param DDMTemplateKey the d d m template key
6173            * @param start the lower bound of the range of journal articles
6174            * @param end the upper bound of the range of journal articles (not inclusive)
6175            * @return the range of matching journal articles that the user has permission to view
6176            */
6177            public static List<JournalArticle> filterFindByG_C_DDMTK(long groupId,
6178                    long classNameId, java.lang.String DDMTemplateKey, int start, int end) {
6179                    return getPersistence()
6180                                       .filterFindByG_C_DDMTK(groupId, classNameId, DDMTemplateKey,
6181                            start, end);
6182            }
6183    
6184            /**
6185            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6186            *
6187            * <p>
6188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6189            * </p>
6190            *
6191            * @param groupId the group ID
6192            * @param classNameId the class name ID
6193            * @param DDMTemplateKey the d d m template key
6194            * @param start the lower bound of the range of journal articles
6195            * @param end the upper bound of the range of journal articles (not inclusive)
6196            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6197            * @return the ordered range of matching journal articles that the user has permission to view
6198            */
6199            public static List<JournalArticle> filterFindByG_C_DDMTK(long groupId,
6200                    long classNameId, java.lang.String DDMTemplateKey, int start, int end,
6201                    OrderByComparator<JournalArticle> orderByComparator) {
6202                    return getPersistence()
6203                                       .filterFindByG_C_DDMTK(groupId, classNameId, DDMTemplateKey,
6204                            start, end, orderByComparator);
6205            }
6206    
6207            /**
6208            * 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 DDMTemplateKey = &#63;.
6209            *
6210            * @param id the primary key of the current journal article
6211            * @param groupId the group ID
6212            * @param classNameId the class name ID
6213            * @param DDMTemplateKey the d d m template key
6214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6215            * @return the previous, current, and next journal article
6216            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6217            */
6218            public static JournalArticle[] filterFindByG_C_DDMTK_PrevAndNext(long id,
6219                    long groupId, long classNameId, java.lang.String DDMTemplateKey,
6220                    OrderByComparator<JournalArticle> orderByComparator)
6221                    throws com.liferay.portlet.journal.NoSuchArticleException {
6222                    return getPersistence()
6223                                       .filterFindByG_C_DDMTK_PrevAndNext(id, groupId, classNameId,
6224                            DDMTemplateKey, orderByComparator);
6225            }
6226    
6227            /**
6228            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63; from the database.
6229            *
6230            * @param groupId the group ID
6231            * @param classNameId the class name ID
6232            * @param DDMTemplateKey the d d m template key
6233            */
6234            public static void removeByG_C_DDMTK(long groupId, long classNameId,
6235                    java.lang.String DDMTemplateKey) {
6236                    getPersistence().removeByG_C_DDMTK(groupId, classNameId, DDMTemplateKey);
6237            }
6238    
6239            /**
6240            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6241            *
6242            * @param groupId the group ID
6243            * @param classNameId the class name ID
6244            * @param DDMTemplateKey the d d m template key
6245            * @return the number of matching journal articles
6246            */
6247            public static int countByG_C_DDMTK(long groupId, long classNameId,
6248                    java.lang.String DDMTemplateKey) {
6249                    return getPersistence()
6250                                       .countByG_C_DDMTK(groupId, classNameId, DDMTemplateKey);
6251            }
6252    
6253            /**
6254            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and DDMTemplateKey = &#63;.
6255            *
6256            * @param groupId the group ID
6257            * @param classNameId the class name ID
6258            * @param DDMTemplateKey the d d m template key
6259            * @return the number of matching journal articles that the user has permission to view
6260            */
6261            public static int filterCountByG_C_DDMTK(long groupId, long classNameId,
6262                    java.lang.String DDMTemplateKey) {
6263                    return getPersistence()
6264                                       .filterCountByG_C_DDMTK(groupId, classNameId, DDMTemplateKey);
6265            }
6266    
6267            /**
6268            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6269            *
6270            * @param groupId the group ID
6271            * @param classNameId the class name ID
6272            * @param layoutUuid the layout uuid
6273            * @return the matching journal articles
6274            */
6275            public static List<JournalArticle> findByG_C_L(long groupId,
6276                    long classNameId, java.lang.String layoutUuid) {
6277                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
6278            }
6279    
6280            /**
6281            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6282            *
6283            * <p>
6284            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6285            * </p>
6286            *
6287            * @param groupId the group ID
6288            * @param classNameId the class name ID
6289            * @param layoutUuid the layout uuid
6290            * @param start the lower bound of the range of journal articles
6291            * @param end the upper bound of the range of journal articles (not inclusive)
6292            * @return the range of matching journal articles
6293            */
6294            public static List<JournalArticle> findByG_C_L(long groupId,
6295                    long classNameId, java.lang.String layoutUuid, int start, int end) {
6296                    return getPersistence()
6297                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
6298            }
6299    
6300            /**
6301            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6302            *
6303            * <p>
6304            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6305            * </p>
6306            *
6307            * @param groupId the group ID
6308            * @param classNameId the class name ID
6309            * @param layoutUuid the layout uuid
6310            * @param start the lower bound of the range of journal articles
6311            * @param end the upper bound of the range of journal articles (not inclusive)
6312            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6313            * @return the ordered range of matching journal articles
6314            */
6315            public static List<JournalArticle> findByG_C_L(long groupId,
6316                    long classNameId, java.lang.String layoutUuid, int start, int end,
6317                    OrderByComparator<JournalArticle> orderByComparator) {
6318                    return getPersistence()
6319                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
6320                            orderByComparator);
6321            }
6322    
6323            /**
6324            * Returns the first journal article in the ordered set 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            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6330            * @return the first matching journal article
6331            * @throws NoSuchArticleException if a matching journal article could not be found
6332            */
6333            public static JournalArticle findByG_C_L_First(long groupId,
6334                    long classNameId, java.lang.String layoutUuid,
6335                    OrderByComparator<JournalArticle> orderByComparator)
6336                    throws com.liferay.portlet.journal.NoSuchArticleException {
6337                    return getPersistence()
6338                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
6339                            orderByComparator);
6340            }
6341    
6342            /**
6343            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6344            *
6345            * @param groupId the group ID
6346            * @param classNameId the class name ID
6347            * @param layoutUuid the layout uuid
6348            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6349            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6350            */
6351            public static JournalArticle fetchByG_C_L_First(long groupId,
6352                    long classNameId, java.lang.String layoutUuid,
6353                    OrderByComparator<JournalArticle> orderByComparator) {
6354                    return getPersistence()
6355                                       .fetchByG_C_L_First(groupId, classNameId, layoutUuid,
6356                            orderByComparator);
6357            }
6358    
6359            /**
6360            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6361            *
6362            * @param groupId the group ID
6363            * @param classNameId the class name ID
6364            * @param layoutUuid the layout uuid
6365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6366            * @return the last matching journal article
6367            * @throws NoSuchArticleException if a matching journal article could not be found
6368            */
6369            public static JournalArticle findByG_C_L_Last(long groupId,
6370                    long classNameId, java.lang.String layoutUuid,
6371                    OrderByComparator<JournalArticle> orderByComparator)
6372                    throws com.liferay.portlet.journal.NoSuchArticleException {
6373                    return getPersistence()
6374                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
6375                            orderByComparator);
6376            }
6377    
6378            /**
6379            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6380            *
6381            * @param groupId the group ID
6382            * @param classNameId the class name ID
6383            * @param layoutUuid the layout uuid
6384            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6385            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6386            */
6387            public static JournalArticle fetchByG_C_L_Last(long groupId,
6388                    long classNameId, java.lang.String layoutUuid,
6389                    OrderByComparator<JournalArticle> orderByComparator) {
6390                    return getPersistence()
6391                                       .fetchByG_C_L_Last(groupId, classNameId, layoutUuid,
6392                            orderByComparator);
6393            }
6394    
6395            /**
6396            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6397            *
6398            * @param id the primary key of the current journal article
6399            * @param groupId the group ID
6400            * @param classNameId the class name ID
6401            * @param layoutUuid the layout uuid
6402            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6403            * @return the previous, current, and next journal article
6404            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6405            */
6406            public static JournalArticle[] findByG_C_L_PrevAndNext(long id,
6407                    long groupId, long classNameId, java.lang.String layoutUuid,
6408                    OrderByComparator<JournalArticle> orderByComparator)
6409                    throws com.liferay.portlet.journal.NoSuchArticleException {
6410                    return getPersistence()
6411                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
6412                            layoutUuid, orderByComparator);
6413            }
6414    
6415            /**
6416            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6417            *
6418            * @param groupId the group ID
6419            * @param classNameId the class name ID
6420            * @param layoutUuid the layout uuid
6421            * @return the matching journal articles that the user has permission to view
6422            */
6423            public static List<JournalArticle> filterFindByG_C_L(long groupId,
6424                    long classNameId, java.lang.String layoutUuid) {
6425                    return getPersistence()
6426                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
6427            }
6428    
6429            /**
6430            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6431            *
6432            * <p>
6433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6434            * </p>
6435            *
6436            * @param groupId the group ID
6437            * @param classNameId the class name ID
6438            * @param layoutUuid the layout uuid
6439            * @param start the lower bound of the range of journal articles
6440            * @param end the upper bound of the range of journal articles (not inclusive)
6441            * @return the range of matching journal articles that the user has permission to view
6442            */
6443            public static List<JournalArticle> filterFindByG_C_L(long groupId,
6444                    long classNameId, java.lang.String layoutUuid, int start, int end) {
6445                    return getPersistence()
6446                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6447                            end);
6448            }
6449    
6450            /**
6451            * 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;.
6452            *
6453            * <p>
6454            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6455            * </p>
6456            *
6457            * @param groupId the group ID
6458            * @param classNameId the class name ID
6459            * @param layoutUuid the layout uuid
6460            * @param start the lower bound of the range of journal articles
6461            * @param end the upper bound of the range of journal articles (not inclusive)
6462            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6463            * @return the ordered range of matching journal articles that the user has permission to view
6464            */
6465            public static List<JournalArticle> filterFindByG_C_L(long groupId,
6466                    long classNameId, java.lang.String layoutUuid, int start, int end,
6467                    OrderByComparator<JournalArticle> orderByComparator) {
6468                    return getPersistence()
6469                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
6470                            end, orderByComparator);
6471            }
6472    
6473            /**
6474            * 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;.
6475            *
6476            * @param id the primary key of the current journal article
6477            * @param groupId the group ID
6478            * @param classNameId the class name ID
6479            * @param layoutUuid the layout uuid
6480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6481            * @return the previous, current, and next journal article
6482            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6483            */
6484            public static JournalArticle[] filterFindByG_C_L_PrevAndNext(long id,
6485                    long groupId, long classNameId, java.lang.String layoutUuid,
6486                    OrderByComparator<JournalArticle> orderByComparator)
6487                    throws com.liferay.portlet.journal.NoSuchArticleException {
6488                    return getPersistence()
6489                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
6490                            layoutUuid, orderByComparator);
6491            }
6492    
6493            /**
6494            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
6495            *
6496            * @param groupId the group ID
6497            * @param classNameId the class name ID
6498            * @param layoutUuid the layout uuid
6499            */
6500            public static void removeByG_C_L(long groupId, long classNameId,
6501                    java.lang.String layoutUuid) {
6502                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
6503            }
6504    
6505            /**
6506            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6507            *
6508            * @param groupId the group ID
6509            * @param classNameId the class name ID
6510            * @param layoutUuid the layout uuid
6511            * @return the number of matching journal articles
6512            */
6513            public static int countByG_C_L(long groupId, long classNameId,
6514                    java.lang.String layoutUuid) {
6515                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
6516            }
6517    
6518            /**
6519            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
6520            *
6521            * @param groupId the group ID
6522            * @param classNameId the class name ID
6523            * @param layoutUuid the layout uuid
6524            * @return the number of matching journal articles that the user has permission to view
6525            */
6526            public static int filterCountByG_C_L(long groupId, long classNameId,
6527                    java.lang.String layoutUuid) {
6528                    return getPersistence()
6529                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
6530            }
6531    
6532            /**
6533            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or throws a {@link NoSuchArticleException} if it could not be found.
6534            *
6535            * @param groupId the group ID
6536            * @param articleId the article ID
6537            * @param version the version
6538            * @return the matching journal article
6539            * @throws NoSuchArticleException if a matching journal article could not be found
6540            */
6541            public static JournalArticle findByG_A_V(long groupId,
6542                    java.lang.String articleId, double version)
6543                    throws com.liferay.portlet.journal.NoSuchArticleException {
6544                    return getPersistence().findByG_A_V(groupId, articleId, version);
6545            }
6546    
6547            /**
6548            * 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.
6549            *
6550            * @param groupId the group ID
6551            * @param articleId the article ID
6552            * @param version the version
6553            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6554            */
6555            public static JournalArticle fetchByG_A_V(long groupId,
6556                    java.lang.String articleId, double version) {
6557                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
6558            }
6559    
6560            /**
6561            * 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.
6562            *
6563            * @param groupId the group ID
6564            * @param articleId the article ID
6565            * @param version the version
6566            * @param retrieveFromCache whether to use the finder cache
6567            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
6568            */
6569            public static JournalArticle fetchByG_A_V(long groupId,
6570                    java.lang.String articleId, double version, boolean retrieveFromCache) {
6571                    return getPersistence()
6572                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
6573            }
6574    
6575            /**
6576            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
6577            *
6578            * @param groupId the group ID
6579            * @param articleId the article ID
6580            * @param version the version
6581            * @return the journal article that was removed
6582            */
6583            public static JournalArticle removeByG_A_V(long groupId,
6584                    java.lang.String articleId, double version)
6585                    throws com.liferay.portlet.journal.NoSuchArticleException {
6586                    return getPersistence().removeByG_A_V(groupId, articleId, version);
6587            }
6588    
6589            /**
6590            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
6591            *
6592            * @param groupId the group ID
6593            * @param articleId the article ID
6594            * @param version the version
6595            * @return the number of matching journal articles
6596            */
6597            public static int countByG_A_V(long groupId, java.lang.String articleId,
6598                    double version) {
6599                    return getPersistence().countByG_A_V(groupId, articleId, version);
6600            }
6601    
6602            /**
6603            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6604            *
6605            * @param groupId the group ID
6606            * @param articleId the article ID
6607            * @param status the status
6608            * @return the matching journal articles
6609            */
6610            public static List<JournalArticle> findByG_A_ST(long groupId,
6611                    java.lang.String articleId, int status) {
6612                    return getPersistence().findByG_A_ST(groupId, articleId, status);
6613            }
6614    
6615            /**
6616            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6617            *
6618            * <p>
6619            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6620            * </p>
6621            *
6622            * @param groupId the group ID
6623            * @param articleId the article ID
6624            * @param status the status
6625            * @param start the lower bound of the range of journal articles
6626            * @param end the upper bound of the range of journal articles (not inclusive)
6627            * @return the range of matching journal articles
6628            */
6629            public static List<JournalArticle> findByG_A_ST(long groupId,
6630                    java.lang.String articleId, int status, int start, int end) {
6631                    return getPersistence()
6632                                       .findByG_A_ST(groupId, articleId, status, start, end);
6633            }
6634    
6635            /**
6636            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6637            *
6638            * <p>
6639            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6640            * </p>
6641            *
6642            * @param groupId the group ID
6643            * @param articleId the article ID
6644            * @param status the status
6645            * @param start the lower bound of the range of journal articles
6646            * @param end the upper bound of the range of journal articles (not inclusive)
6647            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6648            * @return the ordered range of matching journal articles
6649            */
6650            public static List<JournalArticle> findByG_A_ST(long groupId,
6651                    java.lang.String articleId, int status, int start, int end,
6652                    OrderByComparator<JournalArticle> orderByComparator) {
6653                    return getPersistence()
6654                                       .findByG_A_ST(groupId, articleId, status, start, end,
6655                            orderByComparator);
6656            }
6657    
6658            /**
6659            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6660            *
6661            * @param groupId the group ID
6662            * @param articleId the article ID
6663            * @param status the status
6664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6665            * @return the first matching journal article
6666            * @throws NoSuchArticleException if a matching journal article could not be found
6667            */
6668            public static JournalArticle findByG_A_ST_First(long groupId,
6669                    java.lang.String articleId, int status,
6670                    OrderByComparator<JournalArticle> orderByComparator)
6671                    throws com.liferay.portlet.journal.NoSuchArticleException {
6672                    return getPersistence()
6673                                       .findByG_A_ST_First(groupId, articleId, status,
6674                            orderByComparator);
6675            }
6676    
6677            /**
6678            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6679            *
6680            * @param groupId the group ID
6681            * @param articleId the article ID
6682            * @param status the status
6683            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6684            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
6685            */
6686            public static JournalArticle fetchByG_A_ST_First(long groupId,
6687                    java.lang.String articleId, int status,
6688                    OrderByComparator<JournalArticle> orderByComparator) {
6689                    return getPersistence()
6690                                       .fetchByG_A_ST_First(groupId, articleId, status,
6691                            orderByComparator);
6692            }
6693    
6694            /**
6695            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6696            *
6697            * @param groupId the group ID
6698            * @param articleId the article ID
6699            * @param status the status
6700            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6701            * @return the last matching journal article
6702            * @throws NoSuchArticleException if a matching journal article could not be found
6703            */
6704            public static JournalArticle findByG_A_ST_Last(long groupId,
6705                    java.lang.String articleId, int status,
6706                    OrderByComparator<JournalArticle> orderByComparator)
6707                    throws com.liferay.portlet.journal.NoSuchArticleException {
6708                    return getPersistence()
6709                                       .findByG_A_ST_Last(groupId, articleId, status,
6710                            orderByComparator);
6711            }
6712    
6713            /**
6714            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6715            *
6716            * @param groupId the group ID
6717            * @param articleId the article ID
6718            * @param status the status
6719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6720            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
6721            */
6722            public static JournalArticle fetchByG_A_ST_Last(long groupId,
6723                    java.lang.String articleId, int status,
6724                    OrderByComparator<JournalArticle> orderByComparator) {
6725                    return getPersistence()
6726                                       .fetchByG_A_ST_Last(groupId, articleId, status,
6727                            orderByComparator);
6728            }
6729    
6730            /**
6731            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
6732            *
6733            * @param id the primary key of the current journal article
6734            * @param groupId the group ID
6735            * @param articleId the article ID
6736            * @param status the status
6737            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6738            * @return the previous, current, and next journal article
6739            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6740            */
6741            public static JournalArticle[] findByG_A_ST_PrevAndNext(long id,
6742                    long groupId, java.lang.String articleId, int status,
6743                    OrderByComparator<JournalArticle> orderByComparator)
6744                    throws com.liferay.portlet.journal.NoSuchArticleException {
6745                    return getPersistence()
6746                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
6747                            orderByComparator);
6748            }
6749    
6750            /**
6751            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6752            *
6753            * @param groupId the group ID
6754            * @param articleId the article ID
6755            * @param status the status
6756            * @return the matching journal articles that the user has permission to view
6757            */
6758            public static List<JournalArticle> filterFindByG_A_ST(long groupId,
6759                    java.lang.String articleId, int status) {
6760                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
6761            }
6762    
6763            /**
6764            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6765            *
6766            * <p>
6767            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6768            * </p>
6769            *
6770            * @param groupId the group ID
6771            * @param articleId the article ID
6772            * @param status the status
6773            * @param start the lower bound of the range of journal articles
6774            * @param end the upper bound of the range of journal articles (not inclusive)
6775            * @return the range of matching journal articles that the user has permission to view
6776            */
6777            public static List<JournalArticle> filterFindByG_A_ST(long groupId,
6778                    java.lang.String articleId, int status, int start, int end) {
6779                    return getPersistence()
6780                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
6781            }
6782    
6783            /**
6784            * 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;.
6785            *
6786            * <p>
6787            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6788            * </p>
6789            *
6790            * @param groupId the group ID
6791            * @param articleId the article ID
6792            * @param status the status
6793            * @param start the lower bound of the range of journal articles
6794            * @param end the upper bound of the range of journal articles (not inclusive)
6795            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6796            * @return the ordered range of matching journal articles that the user has permission to view
6797            */
6798            public static List<JournalArticle> filterFindByG_A_ST(long groupId,
6799                    java.lang.String articleId, int status, int start, int end,
6800                    OrderByComparator<JournalArticle> orderByComparator) {
6801                    return getPersistence()
6802                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
6803                            orderByComparator);
6804            }
6805    
6806            /**
6807            * 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;.
6808            *
6809            * @param id the primary key of the current journal article
6810            * @param groupId the group ID
6811            * @param articleId the article ID
6812            * @param status the status
6813            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
6814            * @return the previous, current, and next journal article
6815            * @throws NoSuchArticleException if a journal article with the primary key could not be found
6816            */
6817            public static JournalArticle[] filterFindByG_A_ST_PrevAndNext(long id,
6818                    long groupId, java.lang.String articleId, int status,
6819                    OrderByComparator<JournalArticle> orderByComparator)
6820                    throws com.liferay.portlet.journal.NoSuchArticleException {
6821                    return getPersistence()
6822                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
6823                            status, orderByComparator);
6824            }
6825    
6826            /**
6827            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6828            *
6829            * @param groupId the group ID
6830            * @param articleId the article ID
6831            * @param statuses the statuses
6832            * @return the matching journal articles that the user has permission to view
6833            */
6834            public static List<JournalArticle> filterFindByG_A_ST(long groupId,
6835                    java.lang.String articleId, int[] statuses) {
6836                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
6837            }
6838    
6839            /**
6840            * 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;.
6841            *
6842            * <p>
6843            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6844            * </p>
6845            *
6846            * @param groupId the group ID
6847            * @param articleId the article ID
6848            * @param statuses the statuses
6849            * @param start the lower bound of the range of journal articles
6850            * @param end the upper bound of the range of journal articles (not inclusive)
6851            * @return the range of matching journal articles that the user has permission to view
6852            */
6853            public static List<JournalArticle> filterFindByG_A_ST(long groupId,
6854                    java.lang.String articleId, int[] statuses, int start, int end) {
6855                    return getPersistence()
6856                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
6857            }
6858    
6859            /**
6860            * 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;.
6861            *
6862            * <p>
6863            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6864            * </p>
6865            *
6866            * @param groupId the group ID
6867            * @param articleId the article ID
6868            * @param statuses the statuses
6869            * @param start the lower bound of the range of journal articles
6870            * @param end the upper bound of the range of journal articles (not inclusive)
6871            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6872            * @return the ordered range of matching journal articles that the user has permission to view
6873            */
6874            public static List<JournalArticle> filterFindByG_A_ST(long groupId,
6875                    java.lang.String articleId, int[] statuses, int start, int end,
6876                    OrderByComparator<JournalArticle> orderByComparator) {
6877                    return getPersistence()
6878                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
6879                            end, orderByComparator);
6880            }
6881    
6882            /**
6883            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6884            *
6885            * <p>
6886            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6887            * </p>
6888            *
6889            * @param groupId the group ID
6890            * @param articleId the article ID
6891            * @param statuses the statuses
6892            * @return the matching journal articles
6893            */
6894            public static List<JournalArticle> findByG_A_ST(long groupId,
6895                    java.lang.String articleId, int[] statuses) {
6896                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
6897            }
6898    
6899            /**
6900            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6901            *
6902            * <p>
6903            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6904            * </p>
6905            *
6906            * @param groupId the group ID
6907            * @param articleId the article ID
6908            * @param statuses the statuses
6909            * @param start the lower bound of the range of journal articles
6910            * @param end the upper bound of the range of journal articles (not inclusive)
6911            * @return the range of matching journal articles
6912            */
6913            public static List<JournalArticle> findByG_A_ST(long groupId,
6914                    java.lang.String articleId, int[] statuses, int start, int end) {
6915                    return getPersistence()
6916                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
6917            }
6918    
6919            /**
6920            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6921            *
6922            * <p>
6923            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
6924            * </p>
6925            *
6926            * @param groupId the group ID
6927            * @param articleId the article ID
6928            * @param statuses the statuses
6929            * @param start the lower bound of the range of journal articles
6930            * @param end the upper bound of the range of journal articles (not inclusive)
6931            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
6932            * @return the ordered range of matching journal articles
6933            */
6934            public static List<JournalArticle> findByG_A_ST(long groupId,
6935                    java.lang.String articleId, int[] statuses, int start, int end,
6936                    OrderByComparator<JournalArticle> orderByComparator) {
6937                    return getPersistence()
6938                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
6939                            orderByComparator);
6940            }
6941    
6942            /**
6943            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
6944            *
6945            * @param groupId the group ID
6946            * @param articleId the article ID
6947            * @param status the status
6948            */
6949            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
6950                    int status) {
6951                    getPersistence().removeByG_A_ST(groupId, articleId, status);
6952            }
6953    
6954            /**
6955            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
6956            *
6957            * @param groupId the group ID
6958            * @param articleId the article ID
6959            * @param status the status
6960            * @return the number of matching journal articles
6961            */
6962            public static int countByG_A_ST(long groupId, java.lang.String articleId,
6963                    int status) {
6964                    return getPersistence().countByG_A_ST(groupId, articleId, status);
6965            }
6966    
6967            /**
6968            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
6969            *
6970            * @param groupId the group ID
6971            * @param articleId the article ID
6972            * @param statuses the statuses
6973            * @return the number of matching journal articles
6974            */
6975            public static int countByG_A_ST(long groupId, java.lang.String articleId,
6976                    int[] statuses) {
6977                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
6978            }
6979    
6980            /**
6981            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
6982            *
6983            * @param groupId the group ID
6984            * @param articleId the article ID
6985            * @param status the status
6986            * @return the number of matching journal articles that the user has permission to view
6987            */
6988            public static int filterCountByG_A_ST(long groupId,
6989                    java.lang.String articleId, int status) {
6990                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
6991            }
6992    
6993            /**
6994            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
6995            *
6996            * @param groupId the group ID
6997            * @param articleId the article ID
6998            * @param statuses the statuses
6999            * @return the number of matching journal articles that the user has permission to view
7000            */
7001            public static int filterCountByG_A_ST(long groupId,
7002                    java.lang.String articleId, int[] statuses) {
7003                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
7004            }
7005    
7006            /**
7007            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7008            *
7009            * @param groupId the group ID
7010            * @param articleId the article ID
7011            * @param status the status
7012            * @return the matching journal articles
7013            */
7014            public static List<JournalArticle> findByG_A_NotST(long groupId,
7015                    java.lang.String articleId, int status) {
7016                    return getPersistence().findByG_A_NotST(groupId, articleId, status);
7017            }
7018    
7019            /**
7020            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7021            *
7022            * <p>
7023            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7024            * </p>
7025            *
7026            * @param groupId the group ID
7027            * @param articleId the article ID
7028            * @param status the status
7029            * @param start the lower bound of the range of journal articles
7030            * @param end the upper bound of the range of journal articles (not inclusive)
7031            * @return the range of matching journal articles
7032            */
7033            public static List<JournalArticle> findByG_A_NotST(long groupId,
7034                    java.lang.String articleId, int status, int start, int end) {
7035                    return getPersistence()
7036                                       .findByG_A_NotST(groupId, articleId, status, start, end);
7037            }
7038    
7039            /**
7040            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7041            *
7042            * <p>
7043            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7044            * </p>
7045            *
7046            * @param groupId the group ID
7047            * @param articleId the article ID
7048            * @param status the status
7049            * @param start the lower bound of the range of journal articles
7050            * @param end the upper bound of the range of journal articles (not inclusive)
7051            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7052            * @return the ordered range of matching journal articles
7053            */
7054            public static List<JournalArticle> findByG_A_NotST(long groupId,
7055                    java.lang.String articleId, int status, int start, int end,
7056                    OrderByComparator<JournalArticle> orderByComparator) {
7057                    return getPersistence()
7058                                       .findByG_A_NotST(groupId, articleId, status, start, end,
7059                            orderByComparator);
7060            }
7061    
7062            /**
7063            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7064            *
7065            * @param groupId the group ID
7066            * @param articleId the article ID
7067            * @param status the status
7068            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7069            * @return the first matching journal article
7070            * @throws NoSuchArticleException if a matching journal article could not be found
7071            */
7072            public static JournalArticle findByG_A_NotST_First(long groupId,
7073                    java.lang.String articleId, int status,
7074                    OrderByComparator<JournalArticle> orderByComparator)
7075                    throws com.liferay.portlet.journal.NoSuchArticleException {
7076                    return getPersistence()
7077                                       .findByG_A_NotST_First(groupId, articleId, status,
7078                            orderByComparator);
7079            }
7080    
7081            /**
7082            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7083            *
7084            * @param groupId the group ID
7085            * @param articleId the article ID
7086            * @param status the status
7087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7088            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7089            */
7090            public static JournalArticle fetchByG_A_NotST_First(long groupId,
7091                    java.lang.String articleId, int status,
7092                    OrderByComparator<JournalArticle> orderByComparator) {
7093                    return getPersistence()
7094                                       .fetchByG_A_NotST_First(groupId, articleId, status,
7095                            orderByComparator);
7096            }
7097    
7098            /**
7099            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7100            *
7101            * @param groupId the group ID
7102            * @param articleId the article ID
7103            * @param status the status
7104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7105            * @return the last matching journal article
7106            * @throws NoSuchArticleException if a matching journal article could not be found
7107            */
7108            public static JournalArticle findByG_A_NotST_Last(long groupId,
7109                    java.lang.String articleId, int status,
7110                    OrderByComparator<JournalArticle> orderByComparator)
7111                    throws com.liferay.portlet.journal.NoSuchArticleException {
7112                    return getPersistence()
7113                                       .findByG_A_NotST_Last(groupId, articleId, status,
7114                            orderByComparator);
7115            }
7116    
7117            /**
7118            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7119            *
7120            * @param groupId the group ID
7121            * @param articleId the article ID
7122            * @param status the status
7123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7124            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7125            */
7126            public static JournalArticle fetchByG_A_NotST_Last(long groupId,
7127                    java.lang.String articleId, int status,
7128                    OrderByComparator<JournalArticle> orderByComparator) {
7129                    return getPersistence()
7130                                       .fetchByG_A_NotST_Last(groupId, articleId, status,
7131                            orderByComparator);
7132            }
7133    
7134            /**
7135            * 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;.
7136            *
7137            * @param id the primary key of the current journal article
7138            * @param groupId the group ID
7139            * @param articleId the article ID
7140            * @param status the status
7141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7142            * @return the previous, current, and next journal article
7143            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7144            */
7145            public static JournalArticle[] findByG_A_NotST_PrevAndNext(long id,
7146                    long groupId, java.lang.String articleId, int status,
7147                    OrderByComparator<JournalArticle> orderByComparator)
7148                    throws com.liferay.portlet.journal.NoSuchArticleException {
7149                    return getPersistence()
7150                                       .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status,
7151                            orderByComparator);
7152            }
7153    
7154            /**
7155            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7156            *
7157            * @param groupId the group ID
7158            * @param articleId the article ID
7159            * @param status the status
7160            * @return the matching journal articles that the user has permission to view
7161            */
7162            public static List<JournalArticle> filterFindByG_A_NotST(long groupId,
7163                    java.lang.String articleId, int status) {
7164                    return getPersistence().filterFindByG_A_NotST(groupId, articleId, status);
7165            }
7166    
7167            /**
7168            * 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;.
7169            *
7170            * <p>
7171            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7172            * </p>
7173            *
7174            * @param groupId the group ID
7175            * @param articleId the article ID
7176            * @param status the status
7177            * @param start the lower bound of the range of journal articles
7178            * @param end the upper bound of the range of journal articles (not inclusive)
7179            * @return the range of matching journal articles that the user has permission to view
7180            */
7181            public static List<JournalArticle> filterFindByG_A_NotST(long groupId,
7182                    java.lang.String articleId, int status, int start, int end) {
7183                    return getPersistence()
7184                                       .filterFindByG_A_NotST(groupId, articleId, status, start, end);
7185            }
7186    
7187            /**
7188            * 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;.
7189            *
7190            * <p>
7191            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7192            * </p>
7193            *
7194            * @param groupId the group ID
7195            * @param articleId the article ID
7196            * @param status the status
7197            * @param start the lower bound of the range of journal articles
7198            * @param end the upper bound of the range of journal articles (not inclusive)
7199            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7200            * @return the ordered range of matching journal articles that the user has permission to view
7201            */
7202            public static List<JournalArticle> filterFindByG_A_NotST(long groupId,
7203                    java.lang.String articleId, int status, int start, int end,
7204                    OrderByComparator<JournalArticle> orderByComparator) {
7205                    return getPersistence()
7206                                       .filterFindByG_A_NotST(groupId, articleId, status, start,
7207                            end, orderByComparator);
7208            }
7209    
7210            /**
7211            * 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;.
7212            *
7213            * @param id the primary key of the current journal article
7214            * @param groupId the group ID
7215            * @param articleId the article ID
7216            * @param status the status
7217            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7218            * @return the previous, current, and next journal article
7219            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7220            */
7221            public static JournalArticle[] filterFindByG_A_NotST_PrevAndNext(long id,
7222                    long groupId, java.lang.String articleId, int status,
7223                    OrderByComparator<JournalArticle> orderByComparator)
7224                    throws com.liferay.portlet.journal.NoSuchArticleException {
7225                    return getPersistence()
7226                                       .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId,
7227                            status, orderByComparator);
7228            }
7229    
7230            /**
7231            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63; from the database.
7232            *
7233            * @param groupId the group ID
7234            * @param articleId the article ID
7235            * @param status the status
7236            */
7237            public static void removeByG_A_NotST(long groupId,
7238                    java.lang.String articleId, int status) {
7239                    getPersistence().removeByG_A_NotST(groupId, articleId, status);
7240            }
7241    
7242            /**
7243            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7244            *
7245            * @param groupId the group ID
7246            * @param articleId the article ID
7247            * @param status the status
7248            * @return the number of matching journal articles
7249            */
7250            public static int countByG_A_NotST(long groupId,
7251                    java.lang.String articleId, int status) {
7252                    return getPersistence().countByG_A_NotST(groupId, articleId, status);
7253            }
7254    
7255            /**
7256            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status &ne; &#63;.
7257            *
7258            * @param groupId the group ID
7259            * @param articleId the article ID
7260            * @param status the status
7261            * @return the number of matching journal articles that the user has permission to view
7262            */
7263            public static int filterCountByG_A_NotST(long groupId,
7264                    java.lang.String articleId, int status) {
7265                    return getPersistence()
7266                                       .filterCountByG_A_NotST(groupId, articleId, status);
7267            }
7268    
7269            /**
7270            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7271            *
7272            * @param groupId the group ID
7273            * @param urlTitle the url title
7274            * @param status the status
7275            * @return the matching journal articles
7276            */
7277            public static List<JournalArticle> findByG_UT_ST(long groupId,
7278                    java.lang.String urlTitle, int status) {
7279                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
7280            }
7281    
7282            /**
7283            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7284            *
7285            * <p>
7286            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7287            * </p>
7288            *
7289            * @param groupId the group ID
7290            * @param urlTitle the url title
7291            * @param status the status
7292            * @param start the lower bound of the range of journal articles
7293            * @param end the upper bound of the range of journal articles (not inclusive)
7294            * @return the range of matching journal articles
7295            */
7296            public static List<JournalArticle> findByG_UT_ST(long groupId,
7297                    java.lang.String urlTitle, int status, int start, int end) {
7298                    return getPersistence()
7299                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
7300            }
7301    
7302            /**
7303            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7304            *
7305            * <p>
7306            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7307            * </p>
7308            *
7309            * @param groupId the group ID
7310            * @param urlTitle the url title
7311            * @param status the status
7312            * @param start the lower bound of the range of journal articles
7313            * @param end the upper bound of the range of journal articles (not inclusive)
7314            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7315            * @return the ordered range of matching journal articles
7316            */
7317            public static List<JournalArticle> findByG_UT_ST(long groupId,
7318                    java.lang.String urlTitle, int status, int start, int end,
7319                    OrderByComparator<JournalArticle> orderByComparator) {
7320                    return getPersistence()
7321                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
7322                            orderByComparator);
7323            }
7324    
7325            /**
7326            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7327            *
7328            * @param groupId the group ID
7329            * @param urlTitle the url title
7330            * @param status the status
7331            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7332            * @return the first matching journal article
7333            * @throws NoSuchArticleException if a matching journal article could not be found
7334            */
7335            public static JournalArticle findByG_UT_ST_First(long groupId,
7336                    java.lang.String urlTitle, int status,
7337                    OrderByComparator<JournalArticle> orderByComparator)
7338                    throws com.liferay.portlet.journal.NoSuchArticleException {
7339                    return getPersistence()
7340                                       .findByG_UT_ST_First(groupId, urlTitle, status,
7341                            orderByComparator);
7342            }
7343    
7344            /**
7345            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7346            *
7347            * @param groupId the group ID
7348            * @param urlTitle the url title
7349            * @param status the status
7350            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7351            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7352            */
7353            public static JournalArticle fetchByG_UT_ST_First(long groupId,
7354                    java.lang.String urlTitle, int status,
7355                    OrderByComparator<JournalArticle> orderByComparator) {
7356                    return getPersistence()
7357                                       .fetchByG_UT_ST_First(groupId, urlTitle, status,
7358                            orderByComparator);
7359            }
7360    
7361            /**
7362            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7363            *
7364            * @param groupId the group ID
7365            * @param urlTitle the url title
7366            * @param status the status
7367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7368            * @return the last matching journal article
7369            * @throws NoSuchArticleException if a matching journal article could not be found
7370            */
7371            public static JournalArticle findByG_UT_ST_Last(long groupId,
7372                    java.lang.String urlTitle, int status,
7373                    OrderByComparator<JournalArticle> orderByComparator)
7374                    throws com.liferay.portlet.journal.NoSuchArticleException {
7375                    return getPersistence()
7376                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
7377                            orderByComparator);
7378            }
7379    
7380            /**
7381            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7382            *
7383            * @param groupId the group ID
7384            * @param urlTitle the url title
7385            * @param status the status
7386            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7387            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7388            */
7389            public static JournalArticle fetchByG_UT_ST_Last(long groupId,
7390                    java.lang.String urlTitle, int status,
7391                    OrderByComparator<JournalArticle> orderByComparator) {
7392                    return getPersistence()
7393                                       .fetchByG_UT_ST_Last(groupId, urlTitle, status,
7394                            orderByComparator);
7395            }
7396    
7397            /**
7398            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7399            *
7400            * @param id the primary key of the current journal article
7401            * @param groupId the group ID
7402            * @param urlTitle the url title
7403            * @param status the status
7404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7405            * @return the previous, current, and next journal article
7406            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7407            */
7408            public static JournalArticle[] findByG_UT_ST_PrevAndNext(long id,
7409                    long groupId, java.lang.String urlTitle, int status,
7410                    OrderByComparator<JournalArticle> orderByComparator)
7411                    throws com.liferay.portlet.journal.NoSuchArticleException {
7412                    return getPersistence()
7413                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
7414                            orderByComparator);
7415            }
7416    
7417            /**
7418            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7419            *
7420            * @param groupId the group ID
7421            * @param urlTitle the url title
7422            * @param status the status
7423            * @return the matching journal articles that the user has permission to view
7424            */
7425            public static List<JournalArticle> filterFindByG_UT_ST(long groupId,
7426                    java.lang.String urlTitle, int status) {
7427                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
7428            }
7429    
7430            /**
7431            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7432            *
7433            * <p>
7434            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7435            * </p>
7436            *
7437            * @param groupId the group ID
7438            * @param urlTitle the url title
7439            * @param status the status
7440            * @param start the lower bound of the range of journal articles
7441            * @param end the upper bound of the range of journal articles (not inclusive)
7442            * @return the range of matching journal articles that the user has permission to view
7443            */
7444            public static List<JournalArticle> filterFindByG_UT_ST(long groupId,
7445                    java.lang.String urlTitle, int status, int start, int end) {
7446                    return getPersistence()
7447                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
7448            }
7449    
7450            /**
7451            * 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;.
7452            *
7453            * <p>
7454            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7455            * </p>
7456            *
7457            * @param groupId the group ID
7458            * @param urlTitle the url title
7459            * @param status the status
7460            * @param start the lower bound of the range of journal articles
7461            * @param end the upper bound of the range of journal articles (not inclusive)
7462            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7463            * @return the ordered range of matching journal articles that the user has permission to view
7464            */
7465            public static List<JournalArticle> filterFindByG_UT_ST(long groupId,
7466                    java.lang.String urlTitle, int status, int start, int end,
7467                    OrderByComparator<JournalArticle> orderByComparator) {
7468                    return getPersistence()
7469                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
7470                            orderByComparator);
7471            }
7472    
7473            /**
7474            * 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;.
7475            *
7476            * @param id the primary key of the current journal article
7477            * @param groupId the group ID
7478            * @param urlTitle the url title
7479            * @param status the status
7480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7481            * @return the previous, current, and next journal article
7482            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7483            */
7484            public static JournalArticle[] filterFindByG_UT_ST_PrevAndNext(long id,
7485                    long groupId, java.lang.String urlTitle, int status,
7486                    OrderByComparator<JournalArticle> orderByComparator)
7487                    throws com.liferay.portlet.journal.NoSuchArticleException {
7488                    return getPersistence()
7489                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
7490                            status, orderByComparator);
7491            }
7492    
7493            /**
7494            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
7495            *
7496            * @param groupId the group ID
7497            * @param urlTitle the url title
7498            * @param status the status
7499            */
7500            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
7501                    int status) {
7502                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
7503            }
7504    
7505            /**
7506            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7507            *
7508            * @param groupId the group ID
7509            * @param urlTitle the url title
7510            * @param status the status
7511            * @return the number of matching journal articles
7512            */
7513            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
7514                    int status) {
7515                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
7516            }
7517    
7518            /**
7519            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
7520            *
7521            * @param groupId the group ID
7522            * @param urlTitle the url title
7523            * @param status the status
7524            * @return the number of matching journal articles that the user has permission to view
7525            */
7526            public static int filterCountByG_UT_ST(long groupId,
7527                    java.lang.String urlTitle, int status) {
7528                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
7529            }
7530    
7531            /**
7532            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7533            *
7534            * @param companyId the company ID
7535            * @param version the version
7536            * @param status the status
7537            * @return the matching journal articles
7538            */
7539            public static List<JournalArticle> findByC_V_ST(long companyId,
7540                    double version, int status) {
7541                    return getPersistence().findByC_V_ST(companyId, version, status);
7542            }
7543    
7544            /**
7545            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7546            *
7547            * <p>
7548            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7549            * </p>
7550            *
7551            * @param companyId the company ID
7552            * @param version the version
7553            * @param status the status
7554            * @param start the lower bound of the range of journal articles
7555            * @param end the upper bound of the range of journal articles (not inclusive)
7556            * @return the range of matching journal articles
7557            */
7558            public static List<JournalArticle> findByC_V_ST(long companyId,
7559                    double version, int status, int start, int end) {
7560                    return getPersistence()
7561                                       .findByC_V_ST(companyId, version, status, start, end);
7562            }
7563    
7564            /**
7565            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7566            *
7567            * <p>
7568            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7569            * </p>
7570            *
7571            * @param companyId the company ID
7572            * @param version the version
7573            * @param status the status
7574            * @param start the lower bound of the range of journal articles
7575            * @param end the upper bound of the range of journal articles (not inclusive)
7576            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7577            * @return the ordered range of matching journal articles
7578            */
7579            public static List<JournalArticle> findByC_V_ST(long companyId,
7580                    double version, int status, int start, int end,
7581                    OrderByComparator<JournalArticle> orderByComparator) {
7582                    return getPersistence()
7583                                       .findByC_V_ST(companyId, version, status, start, end,
7584                            orderByComparator);
7585            }
7586    
7587            /**
7588            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7589            *
7590            * @param companyId the company ID
7591            * @param version the version
7592            * @param status the status
7593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7594            * @return the first matching journal article
7595            * @throws NoSuchArticleException if a matching journal article could not be found
7596            */
7597            public static JournalArticle findByC_V_ST_First(long companyId,
7598                    double version, int status,
7599                    OrderByComparator<JournalArticle> orderByComparator)
7600                    throws com.liferay.portlet.journal.NoSuchArticleException {
7601                    return getPersistence()
7602                                       .findByC_V_ST_First(companyId, version, status,
7603                            orderByComparator);
7604            }
7605    
7606            /**
7607            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7608            *
7609            * @param companyId the company ID
7610            * @param version the version
7611            * @param status the status
7612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7613            * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found
7614            */
7615            public static JournalArticle fetchByC_V_ST_First(long companyId,
7616                    double version, int status,
7617                    OrderByComparator<JournalArticle> orderByComparator) {
7618                    return getPersistence()
7619                                       .fetchByC_V_ST_First(companyId, version, status,
7620                            orderByComparator);
7621            }
7622    
7623            /**
7624            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7625            *
7626            * @param companyId the company ID
7627            * @param version the version
7628            * @param status the status
7629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7630            * @return the last matching journal article
7631            * @throws NoSuchArticleException if a matching journal article could not be found
7632            */
7633            public static JournalArticle findByC_V_ST_Last(long companyId,
7634                    double version, int status,
7635                    OrderByComparator<JournalArticle> orderByComparator)
7636                    throws com.liferay.portlet.journal.NoSuchArticleException {
7637                    return getPersistence()
7638                                       .findByC_V_ST_Last(companyId, version, status,
7639                            orderByComparator);
7640            }
7641    
7642            /**
7643            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7644            *
7645            * @param companyId the company ID
7646            * @param version the version
7647            * @param status the status
7648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7649            * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found
7650            */
7651            public static JournalArticle fetchByC_V_ST_Last(long companyId,
7652                    double version, int status,
7653                    OrderByComparator<JournalArticle> orderByComparator) {
7654                    return getPersistence()
7655                                       .fetchByC_V_ST_Last(companyId, version, status,
7656                            orderByComparator);
7657            }
7658    
7659            /**
7660            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
7661            *
7662            * @param id the primary key of the current journal article
7663            * @param companyId the company ID
7664            * @param version the version
7665            * @param status the status
7666            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
7667            * @return the previous, current, and next journal article
7668            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7669            */
7670            public static JournalArticle[] findByC_V_ST_PrevAndNext(long id,
7671                    long companyId, double version, int status,
7672                    OrderByComparator<JournalArticle> orderByComparator)
7673                    throws com.liferay.portlet.journal.NoSuchArticleException {
7674                    return getPersistence()
7675                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
7676                            orderByComparator);
7677            }
7678    
7679            /**
7680            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
7681            *
7682            * @param companyId the company ID
7683            * @param version the version
7684            * @param status the status
7685            */
7686            public static void removeByC_V_ST(long companyId, double version, int status) {
7687                    getPersistence().removeByC_V_ST(companyId, version, status);
7688            }
7689    
7690            /**
7691            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
7692            *
7693            * @param companyId the company ID
7694            * @param version the version
7695            * @param status the status
7696            * @return the number of matching journal articles
7697            */
7698            public static int countByC_V_ST(long companyId, double version, int status) {
7699                    return getPersistence().countByC_V_ST(companyId, version, status);
7700            }
7701    
7702            /**
7703            * Caches the journal article in the entity cache if it is enabled.
7704            *
7705            * @param journalArticle the journal article
7706            */
7707            public static void cacheResult(JournalArticle journalArticle) {
7708                    getPersistence().cacheResult(journalArticle);
7709            }
7710    
7711            /**
7712            * Caches the journal articles in the entity cache if it is enabled.
7713            *
7714            * @param journalArticles the journal articles
7715            */
7716            public static void cacheResult(List<JournalArticle> journalArticles) {
7717                    getPersistence().cacheResult(journalArticles);
7718            }
7719    
7720            /**
7721            * Creates a new journal article with the primary key. Does not add the journal article to the database.
7722            *
7723            * @param id the primary key for the new journal article
7724            * @return the new journal article
7725            */
7726            public static JournalArticle create(long id) {
7727                    return getPersistence().create(id);
7728            }
7729    
7730            /**
7731            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
7732            *
7733            * @param id the primary key of the journal article
7734            * @return the journal article that was removed
7735            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7736            */
7737            public static JournalArticle remove(long id)
7738                    throws com.liferay.portlet.journal.NoSuchArticleException {
7739                    return getPersistence().remove(id);
7740            }
7741    
7742            public static JournalArticle updateImpl(JournalArticle journalArticle) {
7743                    return getPersistence().updateImpl(journalArticle);
7744            }
7745    
7746            /**
7747            * Returns the journal article with the primary key or throws a {@link NoSuchArticleException} if it could not be found.
7748            *
7749            * @param id the primary key of the journal article
7750            * @return the journal article
7751            * @throws NoSuchArticleException if a journal article with the primary key could not be found
7752            */
7753            public static JournalArticle findByPrimaryKey(long id)
7754                    throws com.liferay.portlet.journal.NoSuchArticleException {
7755                    return getPersistence().findByPrimaryKey(id);
7756            }
7757    
7758            /**
7759            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
7760            *
7761            * @param id the primary key of the journal article
7762            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
7763            */
7764            public static JournalArticle fetchByPrimaryKey(long id) {
7765                    return getPersistence().fetchByPrimaryKey(id);
7766            }
7767    
7768            public static java.util.Map<java.io.Serializable, JournalArticle> fetchByPrimaryKeys(
7769                    java.util.Set<java.io.Serializable> primaryKeys) {
7770                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
7771            }
7772    
7773            /**
7774            * Returns all the journal articles.
7775            *
7776            * @return the journal articles
7777            */
7778            public static List<JournalArticle> findAll() {
7779                    return getPersistence().findAll();
7780            }
7781    
7782            /**
7783            * Returns a range of all the journal articles.
7784            *
7785            * <p>
7786            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7787            * </p>
7788            *
7789            * @param start the lower bound of the range of journal articles
7790            * @param end the upper bound of the range of journal articles (not inclusive)
7791            * @return the range of journal articles
7792            */
7793            public static List<JournalArticle> findAll(int start, int end) {
7794                    return getPersistence().findAll(start, end);
7795            }
7796    
7797            /**
7798            * Returns an ordered range of all the journal articles.
7799            *
7800            * <p>
7801            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
7802            * </p>
7803            *
7804            * @param start the lower bound of the range of journal articles
7805            * @param end the upper bound of the range of journal articles (not inclusive)
7806            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
7807            * @return the ordered range of journal articles
7808            */
7809            public static List<JournalArticle> findAll(int start, int end,
7810                    OrderByComparator<JournalArticle> orderByComparator) {
7811                    return getPersistence().findAll(start, end, orderByComparator);
7812            }
7813    
7814            /**
7815            * Removes all the journal articles from the database.
7816            */
7817            public static void removeAll() {
7818                    getPersistence().removeAll();
7819            }
7820    
7821            /**
7822            * Returns the number of journal articles.
7823            *
7824            * @return the number of journal articles
7825            */
7826            public static int countAll() {
7827                    return getPersistence().countAll();
7828            }
7829    
7830            public static JournalArticlePersistence getPersistence() {
7831                    if (_persistence == null) {
7832                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
7833    
7834                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
7835                                    "_persistence");
7836                    }
7837    
7838                    return _persistence;
7839            }
7840    
7841            /**
7842             * @deprecated As of 6.2.0
7843             */
7844            @Deprecated
7845            public void setPersistence(JournalArticlePersistence persistence) {
7846            }
7847    
7848            private static JournalArticlePersistence _persistence;
7849    }