001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.journal.model.JournalArticle;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see JournalArticlePersistence
037     * @see JournalArticlePersistenceImpl
038     * @generated
039     */
040    public class JournalArticleUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(JournalArticle journalArticle) {
058                    getPersistence().clearCache(journalArticle);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<JournalArticle> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<JournalArticle> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalArticle> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
099             */
100            public static JournalArticle update(JournalArticle journalArticle,
101                    boolean merge) throws SystemException {
102                    return getPersistence().update(journalArticle, merge);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
107             */
108            public static JournalArticle update(JournalArticle journalArticle,
109                    boolean merge, ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(journalArticle, merge, serviceContext);
111            }
112    
113            /**
114            * Caches the journal article in the entity cache if it is enabled.
115            *
116            * @param journalArticle the journal article
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.journal.model.JournalArticle journalArticle) {
120                    getPersistence().cacheResult(journalArticle);
121            }
122    
123            /**
124            * Caches the journal articles in the entity cache if it is enabled.
125            *
126            * @param journalArticles the journal articles
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) {
130                    getPersistence().cacheResult(journalArticles);
131            }
132    
133            /**
134            * Creates a new journal article with the primary key. Does not add the journal article to the database.
135            *
136            * @param id the primary key for the new journal article
137            * @return the new journal article
138            */
139            public static com.liferay.portlet.journal.model.JournalArticle create(
140                    long id) {
141                    return getPersistence().create(id);
142            }
143    
144            /**
145            * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners.
146            *
147            * @param id the primary key of the journal article
148            * @return the journal article that was removed
149            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
150            * @throws SystemException if a system exception occurred
151            */
152            public static com.liferay.portlet.journal.model.JournalArticle remove(
153                    long id)
154                    throws com.liferay.portal.kernel.exception.SystemException,
155                            com.liferay.portlet.journal.NoSuchArticleException {
156                    return getPersistence().remove(id);
157            }
158    
159            public static com.liferay.portlet.journal.model.JournalArticle updateImpl(
160                    com.liferay.portlet.journal.model.JournalArticle journalArticle,
161                    boolean merge)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().updateImpl(journalArticle, merge);
164            }
165    
166            /**
167            * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
168            *
169            * @param id the primary key of the journal article
170            * @return the journal article
171            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey(
175                    long id)
176                    throws com.liferay.portal.kernel.exception.SystemException,
177                            com.liferay.portlet.journal.NoSuchArticleException {
178                    return getPersistence().findByPrimaryKey(id);
179            }
180    
181            /**
182            * Returns the journal article with the primary key or returns <code>null</code> if it could not be found.
183            *
184            * @param id the primary key of the journal article
185            * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found
186            * @throws SystemException if a system exception occurred
187            */
188            public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey(
189                    long id) throws com.liferay.portal.kernel.exception.SystemException {
190                    return getPersistence().fetchByPrimaryKey(id);
191            }
192    
193            /**
194            * Returns all the journal articles where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @return the matching journal articles
198            * @throws SystemException if a system exception occurred
199            */
200            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
201                    java.lang.String uuid)
202                    throws com.liferay.portal.kernel.exception.SystemException {
203                    return getPersistence().findByUuid(uuid);
204            }
205    
206            /**
207            * Returns a range of all the journal articles where uuid = &#63;.
208            *
209            * <p>
210            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
211            * </p>
212            *
213            * @param uuid the uuid
214            * @param start the lower bound of the range of journal articles
215            * @param end the upper bound of the range of journal articles (not inclusive)
216            * @return the range of matching journal articles
217            * @throws SystemException if a system exception occurred
218            */
219            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
220                    java.lang.String uuid, int start, int end)
221                    throws com.liferay.portal.kernel.exception.SystemException {
222                    return getPersistence().findByUuid(uuid, start, end);
223            }
224    
225            /**
226            * Returns an ordered range of all the journal articles where uuid = &#63;.
227            *
228            * <p>
229            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
230            * </p>
231            *
232            * @param uuid the uuid
233            * @param start the lower bound of the range of journal articles
234            * @param end the upper bound of the range of journal articles (not inclusive)
235            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
236            * @return the ordered range of matching journal articles
237            * @throws SystemException if a system exception occurred
238            */
239            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid(
240                    java.lang.String uuid, int start, int end,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.kernel.exception.SystemException {
243                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
244            }
245    
246            /**
247            * Returns the first journal article in the ordered set where uuid = &#63;.
248            *
249            * <p>
250            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
251            * </p>
252            *
253            * @param uuid the uuid
254            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
255            * @return the first matching journal article
256            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
257            * @throws SystemException if a system exception occurred
258            */
259            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First(
260                    java.lang.String uuid,
261                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
262                    throws com.liferay.portal.kernel.exception.SystemException,
263                            com.liferay.portlet.journal.NoSuchArticleException {
264                    return getPersistence().findByUuid_First(uuid, orderByComparator);
265            }
266    
267            /**
268            * Returns the last journal article in the ordered set where uuid = &#63;.
269            *
270            * <p>
271            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
272            * </p>
273            *
274            * @param uuid the uuid
275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
276            * @return the last matching journal article
277            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
278            * @throws SystemException if a system exception occurred
279            */
280            public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last(
281                    java.lang.String uuid,
282                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.journal.NoSuchArticleException {
285                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
286            }
287    
288            /**
289            * Returns the journal articles before and after the current journal article in the ordered set where uuid = &#63;.
290            *
291            * <p>
292            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
293            * </p>
294            *
295            * @param id the primary key of the current journal article
296            * @param uuid the uuid
297            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
298            * @return the previous, current, and next journal article
299            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
300            * @throws SystemException if a system exception occurred
301            */
302            public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext(
303                    long id, java.lang.String uuid,
304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
305                    throws com.liferay.portal.kernel.exception.SystemException,
306                            com.liferay.portlet.journal.NoSuchArticleException {
307                    return getPersistence()
308                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
309            }
310    
311            /**
312            * Returns the journal article where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
313            *
314            * @param uuid the uuid
315            * @param groupId the group ID
316            * @return the matching journal article
317            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
318            * @throws SystemException if a system exception occurred
319            */
320            public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G(
321                    java.lang.String uuid, long groupId)
322                    throws com.liferay.portal.kernel.exception.SystemException,
323                            com.liferay.portlet.journal.NoSuchArticleException {
324                    return getPersistence().findByUUID_G(uuid, groupId);
325            }
326    
327            /**
328            * 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.
329            *
330            * @param uuid the uuid
331            * @param groupId the group ID
332            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
333            * @throws SystemException if a system exception occurred
334            */
335            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
336                    java.lang.String uuid, long groupId)
337                    throws com.liferay.portal.kernel.exception.SystemException {
338                    return getPersistence().fetchByUUID_G(uuid, groupId);
339            }
340    
341            /**
342            * 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.
343            *
344            * @param uuid the uuid
345            * @param groupId the group ID
346            * @param retrieveFromCache whether to use the finder cache
347            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
348            * @throws SystemException if a system exception occurred
349            */
350            public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G(
351                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
352                    throws com.liferay.portal.kernel.exception.SystemException {
353                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
354            }
355    
356            /**
357            * Returns all the journal articles where resourcePrimKey = &#63;.
358            *
359            * @param resourcePrimKey the resource prim key
360            * @return the matching journal articles
361            * @throws SystemException if a system exception occurred
362            */
363            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
364                    long resourcePrimKey)
365                    throws com.liferay.portal.kernel.exception.SystemException {
366                    return getPersistence().findByResourcePrimKey(resourcePrimKey);
367            }
368    
369            /**
370            * Returns a range of all the journal articles where resourcePrimKey = &#63;.
371            *
372            * <p>
373            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
374            * </p>
375            *
376            * @param resourcePrimKey the resource prim key
377            * @param start the lower bound of the range of journal articles
378            * @param end the upper bound of the range of journal articles (not inclusive)
379            * @return the range of matching journal articles
380            * @throws SystemException if a system exception occurred
381            */
382            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
383                    long resourcePrimKey, int start, int end)
384                    throws com.liferay.portal.kernel.exception.SystemException {
385                    return getPersistence()
386                                       .findByResourcePrimKey(resourcePrimKey, start, end);
387            }
388    
389            /**
390            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63;.
391            *
392            * <p>
393            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
394            * </p>
395            *
396            * @param resourcePrimKey the resource prim key
397            * @param start the lower bound of the range of journal articles
398            * @param end the upper bound of the range of journal articles (not inclusive)
399            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
400            * @return the ordered range of matching journal articles
401            * @throws SystemException if a system exception occurred
402            */
403            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey(
404                    long resourcePrimKey, int start, int end,
405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
406                    throws com.liferay.portal.kernel.exception.SystemException {
407                    return getPersistence()
408                                       .findByResourcePrimKey(resourcePrimKey, start, end,
409                            orderByComparator);
410            }
411    
412            /**
413            * Returns the first journal article in the ordered set where resourcePrimKey = &#63;.
414            *
415            * <p>
416            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
417            * </p>
418            *
419            * @param resourcePrimKey the resource prim key
420            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
421            * @return the first matching journal article
422            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
423            * @throws SystemException if a system exception occurred
424            */
425            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First(
426                    long resourcePrimKey,
427                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
428                    throws com.liferay.portal.kernel.exception.SystemException,
429                            com.liferay.portlet.journal.NoSuchArticleException {
430                    return getPersistence()
431                                       .findByResourcePrimKey_First(resourcePrimKey,
432                            orderByComparator);
433            }
434    
435            /**
436            * Returns the last journal article in the ordered set where resourcePrimKey = &#63;.
437            *
438            * <p>
439            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
440            * </p>
441            *
442            * @param resourcePrimKey the resource prim key
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching journal article
445            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last(
449                    long resourcePrimKey,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.journal.NoSuchArticleException {
453                    return getPersistence()
454                                       .findByResourcePrimKey_Last(resourcePrimKey,
455                            orderByComparator);
456            }
457    
458            /**
459            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63;.
460            *
461            * <p>
462            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
463            * </p>
464            *
465            * @param id the primary key of the current journal article
466            * @param resourcePrimKey the resource prim key
467            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
468            * @return the previous, current, and next journal article
469            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
470            * @throws SystemException if a system exception occurred
471            */
472            public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext(
473                    long id, long resourcePrimKey,
474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
475                    throws com.liferay.portal.kernel.exception.SystemException,
476                            com.liferay.portlet.journal.NoSuchArticleException {
477                    return getPersistence()
478                                       .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey,
479                            orderByComparator);
480            }
481    
482            /**
483            * Returns all the journal articles where groupId = &#63;.
484            *
485            * @param groupId the group ID
486            * @return the matching journal articles
487            * @throws SystemException if a system exception occurred
488            */
489            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
490                    long groupId)
491                    throws com.liferay.portal.kernel.exception.SystemException {
492                    return getPersistence().findByGroupId(groupId);
493            }
494    
495            /**
496            * Returns a range of all the journal articles where groupId = &#63;.
497            *
498            * <p>
499            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
500            * </p>
501            *
502            * @param groupId the group ID
503            * @param start the lower bound of the range of journal articles
504            * @param end the upper bound of the range of journal articles (not inclusive)
505            * @return the range of matching journal articles
506            * @throws SystemException if a system exception occurred
507            */
508            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
509                    long groupId, int start, int end)
510                    throws com.liferay.portal.kernel.exception.SystemException {
511                    return getPersistence().findByGroupId(groupId, start, end);
512            }
513    
514            /**
515            * Returns an ordered range of all the journal articles where groupId = &#63;.
516            *
517            * <p>
518            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
519            * </p>
520            *
521            * @param groupId the group ID
522            * @param start the lower bound of the range of journal articles
523            * @param end the upper bound of the range of journal articles (not inclusive)
524            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
525            * @return the ordered range of matching journal articles
526            * @throws SystemException if a system exception occurred
527            */
528            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId(
529                    long groupId, int start, int end,
530                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
531                    throws com.liferay.portal.kernel.exception.SystemException {
532                    return getPersistence()
533                                       .findByGroupId(groupId, start, end, orderByComparator);
534            }
535    
536            /**
537            * Returns the first journal article in the ordered set where groupId = &#63;.
538            *
539            * <p>
540            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
541            * </p>
542            *
543            * @param groupId the group ID
544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
545            * @return the first matching journal article
546            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
547            * @throws SystemException if a system exception occurred
548            */
549            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First(
550                    long groupId,
551                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
552                    throws com.liferay.portal.kernel.exception.SystemException,
553                            com.liferay.portlet.journal.NoSuchArticleException {
554                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
555            }
556    
557            /**
558            * Returns the last journal article in the ordered set where groupId = &#63;.
559            *
560            * <p>
561            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
562            * </p>
563            *
564            * @param groupId the group ID
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the last matching journal article
567            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
568            * @throws SystemException if a system exception occurred
569            */
570            public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last(
571                    long groupId,
572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
573                    throws com.liferay.portal.kernel.exception.SystemException,
574                            com.liferay.portlet.journal.NoSuchArticleException {
575                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
576            }
577    
578            /**
579            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63;.
580            *
581            * <p>
582            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
583            * </p>
584            *
585            * @param id the primary key of the current journal article
586            * @param groupId the group ID
587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
588            * @return the previous, current, and next journal article
589            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
590            * @throws SystemException if a system exception occurred
591            */
592            public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext(
593                    long id, long groupId,
594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
595                    throws com.liferay.portal.kernel.exception.SystemException,
596                            com.liferay.portlet.journal.NoSuchArticleException {
597                    return getPersistence()
598                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
599            }
600    
601            /**
602            * Returns all the journal articles that the user has permission to view where groupId = &#63;.
603            *
604            * @param groupId the group ID
605            * @return the matching journal articles that the user has permission to view
606            * @throws SystemException if a system exception occurred
607            */
608            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
609                    long groupId)
610                    throws com.liferay.portal.kernel.exception.SystemException {
611                    return getPersistence().filterFindByGroupId(groupId);
612            }
613    
614            /**
615            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63;.
616            *
617            * <p>
618            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
619            * </p>
620            *
621            * @param groupId the group ID
622            * @param start the lower bound of the range of journal articles
623            * @param end the upper bound of the range of journal articles (not inclusive)
624            * @return the range of matching journal articles that the user has permission to view
625            * @throws SystemException if a system exception occurred
626            */
627            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
628                    long groupId, int start, int end)
629                    throws com.liferay.portal.kernel.exception.SystemException {
630                    return getPersistence().filterFindByGroupId(groupId, start, end);
631            }
632    
633            /**
634            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63;.
635            *
636            * <p>
637            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
638            * </p>
639            *
640            * @param groupId the group ID
641            * @param start the lower bound of the range of journal articles
642            * @param end the upper bound of the range of journal articles (not inclusive)
643            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
644            * @return the ordered range of matching journal articles that the user has permission to view
645            * @throws SystemException if a system exception occurred
646            */
647            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId(
648                    long groupId, int start, int end,
649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
650                    throws com.liferay.portal.kernel.exception.SystemException {
651                    return getPersistence()
652                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
653            }
654    
655            /**
656            * 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;.
657            *
658            * @param id the primary key of the current journal article
659            * @param groupId the group ID
660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
661            * @return the previous, current, and next journal article
662            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
663            * @throws SystemException if a system exception occurred
664            */
665            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext(
666                    long id, long groupId,
667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
668                    throws com.liferay.portal.kernel.exception.SystemException,
669                            com.liferay.portlet.journal.NoSuchArticleException {
670                    return getPersistence()
671                                       .filterFindByGroupId_PrevAndNext(id, groupId,
672                            orderByComparator);
673            }
674    
675            /**
676            * Returns all the journal articles where companyId = &#63;.
677            *
678            * @param companyId the company ID
679            * @return the matching journal articles
680            * @throws SystemException if a system exception occurred
681            */
682            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
683                    long companyId)
684                    throws com.liferay.portal.kernel.exception.SystemException {
685                    return getPersistence().findByCompanyId(companyId);
686            }
687    
688            /**
689            * Returns a range of all the journal articles where companyId = &#63;.
690            *
691            * <p>
692            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
693            * </p>
694            *
695            * @param companyId the company ID
696            * @param start the lower bound of the range of journal articles
697            * @param end the upper bound of the range of journal articles (not inclusive)
698            * @return the range of matching journal articles
699            * @throws SystemException if a system exception occurred
700            */
701            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
702                    long companyId, int start, int end)
703                    throws com.liferay.portal.kernel.exception.SystemException {
704                    return getPersistence().findByCompanyId(companyId, start, end);
705            }
706    
707            /**
708            * Returns an ordered range of all the journal articles where companyId = &#63;.
709            *
710            * <p>
711            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
712            * </p>
713            *
714            * @param companyId the company ID
715            * @param start the lower bound of the range of journal articles
716            * @param end the upper bound of the range of journal articles (not inclusive)
717            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
718            * @return the ordered range of matching journal articles
719            * @throws SystemException if a system exception occurred
720            */
721            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId(
722                    long companyId, int start, int end,
723                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
724                    throws com.liferay.portal.kernel.exception.SystemException {
725                    return getPersistence()
726                                       .findByCompanyId(companyId, start, end, orderByComparator);
727            }
728    
729            /**
730            * Returns the first journal article in the ordered set where companyId = &#63;.
731            *
732            * <p>
733            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
734            * </p>
735            *
736            * @param companyId the company ID
737            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
738            * @return the first matching journal article
739            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
740            * @throws SystemException if a system exception occurred
741            */
742            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First(
743                    long companyId,
744                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
745                    throws com.liferay.portal.kernel.exception.SystemException,
746                            com.liferay.portlet.journal.NoSuchArticleException {
747                    return getPersistence()
748                                       .findByCompanyId_First(companyId, orderByComparator);
749            }
750    
751            /**
752            * Returns the last journal article in the ordered set where companyId = &#63;.
753            *
754            * <p>
755            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
756            * </p>
757            *
758            * @param companyId the company ID
759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
760            * @return the last matching journal article
761            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
762            * @throws SystemException if a system exception occurred
763            */
764            public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last(
765                    long companyId,
766                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
767                    throws com.liferay.portal.kernel.exception.SystemException,
768                            com.liferay.portlet.journal.NoSuchArticleException {
769                    return getPersistence()
770                                       .findByCompanyId_Last(companyId, orderByComparator);
771            }
772    
773            /**
774            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63;.
775            *
776            * <p>
777            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
778            * </p>
779            *
780            * @param id the primary key of the current journal article
781            * @param companyId the company ID
782            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
783            * @return the previous, current, and next journal article
784            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
785            * @throws SystemException if a system exception occurred
786            */
787            public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext(
788                    long id, long companyId,
789                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
790                    throws com.liferay.portal.kernel.exception.SystemException,
791                            com.liferay.portlet.journal.NoSuchArticleException {
792                    return getPersistence()
793                                       .findByCompanyId_PrevAndNext(id, companyId, orderByComparator);
794            }
795    
796            /**
797            * Returns all the journal articles where smallImageId = &#63;.
798            *
799            * @param smallImageId the small image ID
800            * @return the matching journal articles
801            * @throws SystemException if a system exception occurred
802            */
803            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
804                    long smallImageId)
805                    throws com.liferay.portal.kernel.exception.SystemException {
806                    return getPersistence().findBySmallImageId(smallImageId);
807            }
808    
809            /**
810            * Returns a range of all the journal articles where smallImageId = &#63;.
811            *
812            * <p>
813            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
814            * </p>
815            *
816            * @param smallImageId the small image ID
817            * @param start the lower bound of the range of journal articles
818            * @param end the upper bound of the range of journal articles (not inclusive)
819            * @return the range of matching journal articles
820            * @throws SystemException if a system exception occurred
821            */
822            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
823                    long smallImageId, int start, int end)
824                    throws com.liferay.portal.kernel.exception.SystemException {
825                    return getPersistence().findBySmallImageId(smallImageId, start, end);
826            }
827    
828            /**
829            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
830            *
831            * <p>
832            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
833            * </p>
834            *
835            * @param smallImageId the small image ID
836            * @param start the lower bound of the range of journal articles
837            * @param end the upper bound of the range of journal articles (not inclusive)
838            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
839            * @return the ordered range of matching journal articles
840            * @throws SystemException if a system exception occurred
841            */
842            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
843                    long smallImageId, int start, int end,
844                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
845                    throws com.liferay.portal.kernel.exception.SystemException {
846                    return getPersistence()
847                                       .findBySmallImageId(smallImageId, start, end,
848                            orderByComparator);
849            }
850    
851            /**
852            * Returns the first journal article in the ordered set where smallImageId = &#63;.
853            *
854            * <p>
855            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
856            * </p>
857            *
858            * @param smallImageId the small image ID
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the first matching journal article
861            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
862            * @throws SystemException if a system exception occurred
863            */
864            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
865                    long smallImageId,
866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
867                    throws com.liferay.portal.kernel.exception.SystemException,
868                            com.liferay.portlet.journal.NoSuchArticleException {
869                    return getPersistence()
870                                       .findBySmallImageId_First(smallImageId, orderByComparator);
871            }
872    
873            /**
874            * Returns the last journal article in the ordered set where smallImageId = &#63;.
875            *
876            * <p>
877            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
878            * </p>
879            *
880            * @param smallImageId the small image ID
881            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
882            * @return the last matching journal article
883            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
884            * @throws SystemException if a system exception occurred
885            */
886            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
887                    long smallImageId,
888                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
889                    throws com.liferay.portal.kernel.exception.SystemException,
890                            com.liferay.portlet.journal.NoSuchArticleException {
891                    return getPersistence()
892                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
893            }
894    
895            /**
896            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
897            *
898            * <p>
899            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
900            * </p>
901            *
902            * @param id the primary key of the current journal article
903            * @param smallImageId the small image ID
904            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
905            * @return the previous, current, and next journal article
906            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
907            * @throws SystemException if a system exception occurred
908            */
909            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
910                    long id, long smallImageId,
911                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
912                    throws com.liferay.portal.kernel.exception.SystemException,
913                            com.liferay.portlet.journal.NoSuchArticleException {
914                    return getPersistence()
915                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
916                            orderByComparator);
917            }
918    
919            /**
920            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
921            *
922            * @param resourcePrimKey the resource prim key
923            * @param status the status
924            * @return the matching journal articles
925            * @throws SystemException if a system exception occurred
926            */
927            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
928                    long resourcePrimKey, int status)
929                    throws com.liferay.portal.kernel.exception.SystemException {
930                    return getPersistence().findByR_ST(resourcePrimKey, status);
931            }
932    
933            /**
934            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
935            *
936            * <p>
937            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
938            * </p>
939            *
940            * @param resourcePrimKey the resource prim key
941            * @param status the status
942            * @param start the lower bound of the range of journal articles
943            * @param end the upper bound of the range of journal articles (not inclusive)
944            * @return the range of matching journal articles
945            * @throws SystemException if a system exception occurred
946            */
947            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
948                    long resourcePrimKey, int status, int start, int end)
949                    throws com.liferay.portal.kernel.exception.SystemException {
950                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
951            }
952    
953            /**
954            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
955            *
956            * <p>
957            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
958            * </p>
959            *
960            * @param resourcePrimKey the resource prim key
961            * @param status the status
962            * @param start the lower bound of the range of journal articles
963            * @param end the upper bound of the range of journal articles (not inclusive)
964            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
965            * @return the ordered range of matching journal articles
966            * @throws SystemException if a system exception occurred
967            */
968            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
969                    long resourcePrimKey, int status, int start, int end,
970                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
971                    throws com.liferay.portal.kernel.exception.SystemException {
972                    return getPersistence()
973                                       .findByR_ST(resourcePrimKey, status, start, end,
974                            orderByComparator);
975            }
976    
977            /**
978            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
979            *
980            * <p>
981            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
982            * </p>
983            *
984            * @param resourcePrimKey the resource prim key
985            * @param status the status
986            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
987            * @return the first matching journal article
988            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
989            * @throws SystemException if a system exception occurred
990            */
991            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
992                    long resourcePrimKey, int status,
993                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
994                    throws com.liferay.portal.kernel.exception.SystemException,
995                            com.liferay.portlet.journal.NoSuchArticleException {
996                    return getPersistence()
997                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
998            }
999    
1000            /**
1001            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1002            *
1003            * <p>
1004            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1005            * </p>
1006            *
1007            * @param resourcePrimKey the resource prim key
1008            * @param status the status
1009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1010            * @return the last matching journal article
1011            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1012            * @throws SystemException if a system exception occurred
1013            */
1014            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1015                    long resourcePrimKey, int status,
1016                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1017                    throws com.liferay.portal.kernel.exception.SystemException,
1018                            com.liferay.portlet.journal.NoSuchArticleException {
1019                    return getPersistence()
1020                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1021            }
1022    
1023            /**
1024            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1025            *
1026            * <p>
1027            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1028            * </p>
1029            *
1030            * @param id the primary key of the current journal article
1031            * @param resourcePrimKey the resource prim key
1032            * @param status the status
1033            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1034            * @return the previous, current, and next journal article
1035            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1036            * @throws SystemException if a system exception occurred
1037            */
1038            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1039                    long id, long resourcePrimKey, int status,
1040                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1041                    throws com.liferay.portal.kernel.exception.SystemException,
1042                            com.liferay.portlet.journal.NoSuchArticleException {
1043                    return getPersistence()
1044                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1045                            orderByComparator);
1046            }
1047    
1048            /**
1049            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
1050            *
1051            * @param groupId the group ID
1052            * @param articleId the article ID
1053            * @return the matching journal articles
1054            * @throws SystemException if a system exception occurred
1055            */
1056            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1057                    long groupId, java.lang.String articleId)
1058                    throws com.liferay.portal.kernel.exception.SystemException {
1059                    return getPersistence().findByG_A(groupId, articleId);
1060            }
1061    
1062            /**
1063            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
1064            *
1065            * <p>
1066            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1067            * </p>
1068            *
1069            * @param groupId the group ID
1070            * @param articleId the article ID
1071            * @param start the lower bound of the range of journal articles
1072            * @param end the upper bound of the range of journal articles (not inclusive)
1073            * @return the range of matching journal articles
1074            * @throws SystemException if a system exception occurred
1075            */
1076            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1077                    long groupId, java.lang.String articleId, int start, int end)
1078                    throws com.liferay.portal.kernel.exception.SystemException {
1079                    return getPersistence().findByG_A(groupId, articleId, start, end);
1080            }
1081    
1082            /**
1083            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
1084            *
1085            * <p>
1086            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1087            * </p>
1088            *
1089            * @param groupId the group ID
1090            * @param articleId the article ID
1091            * @param start the lower bound of the range of journal articles
1092            * @param end the upper bound of the range of journal articles (not inclusive)
1093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1094            * @return the ordered range of matching journal articles
1095            * @throws SystemException if a system exception occurred
1096            */
1097            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1098                    long groupId, java.lang.String articleId, int start, int end,
1099                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    return getPersistence()
1102                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
1103            }
1104    
1105            /**
1106            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1107            *
1108            * <p>
1109            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1110            * </p>
1111            *
1112            * @param groupId the group ID
1113            * @param articleId the article ID
1114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1115            * @return the first matching journal article
1116            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1117            * @throws SystemException if a system exception occurred
1118            */
1119            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
1120                    long groupId, java.lang.String articleId,
1121                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1122                    throws com.liferay.portal.kernel.exception.SystemException,
1123                            com.liferay.portlet.journal.NoSuchArticleException {
1124                    return getPersistence()
1125                                       .findByG_A_First(groupId, articleId, orderByComparator);
1126            }
1127    
1128            /**
1129            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1130            *
1131            * <p>
1132            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1133            * </p>
1134            *
1135            * @param groupId the group ID
1136            * @param articleId the article ID
1137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1138            * @return the last matching journal article
1139            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1140            * @throws SystemException if a system exception occurred
1141            */
1142            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
1143                    long groupId, java.lang.String articleId,
1144                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1145                    throws com.liferay.portal.kernel.exception.SystemException,
1146                            com.liferay.portlet.journal.NoSuchArticleException {
1147                    return getPersistence()
1148                                       .findByG_A_Last(groupId, articleId, orderByComparator);
1149            }
1150    
1151            /**
1152            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1153            *
1154            * <p>
1155            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1156            * </p>
1157            *
1158            * @param id the primary key of the current journal article
1159            * @param groupId the group ID
1160            * @param articleId the article ID
1161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1162            * @return the previous, current, and next journal article
1163            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1164            * @throws SystemException if a system exception occurred
1165            */
1166            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
1167                    long id, long groupId, java.lang.String articleId,
1168                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1169                    throws com.liferay.portal.kernel.exception.SystemException,
1170                            com.liferay.portlet.journal.NoSuchArticleException {
1171                    return getPersistence()
1172                                       .findByG_A_PrevAndNext(id, groupId, articleId,
1173                            orderByComparator);
1174            }
1175    
1176            /**
1177            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1178            *
1179            * @param groupId the group ID
1180            * @param articleId the article ID
1181            * @return the matching journal articles that the user has permission to view
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1185                    long groupId, java.lang.String articleId)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence().filterFindByG_A(groupId, articleId);
1188            }
1189    
1190            /**
1191            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1192            *
1193            * <p>
1194            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1195            * </p>
1196            *
1197            * @param groupId the group ID
1198            * @param articleId the article ID
1199            * @param start the lower bound of the range of journal articles
1200            * @param end the upper bound of the range of journal articles (not inclusive)
1201            * @return the range of matching journal articles that the user has permission to view
1202            * @throws SystemException if a system exception occurred
1203            */
1204            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1205                    long groupId, java.lang.String articleId, int start, int end)
1206                    throws com.liferay.portal.kernel.exception.SystemException {
1207                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
1208            }
1209    
1210            /**
1211            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
1212            *
1213            * <p>
1214            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1215            * </p>
1216            *
1217            * @param groupId the group ID
1218            * @param articleId the article ID
1219            * @param start the lower bound of the range of journal articles
1220            * @param end the upper bound of the range of journal articles (not inclusive)
1221            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1222            * @return the ordered range of matching journal articles that the user has permission to view
1223            * @throws SystemException if a system exception occurred
1224            */
1225            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1226                    long groupId, java.lang.String articleId, int start, int end,
1227                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1228                    throws com.liferay.portal.kernel.exception.SystemException {
1229                    return getPersistence()
1230                                       .filterFindByG_A(groupId, articleId, start, end,
1231                            orderByComparator);
1232            }
1233    
1234            /**
1235            * 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;.
1236            *
1237            * @param id the primary key of the current journal article
1238            * @param groupId the group ID
1239            * @param articleId the article ID
1240            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1241            * @return the previous, current, and next journal article
1242            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1243            * @throws SystemException if a system exception occurred
1244            */
1245            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
1246                    long id, long groupId, java.lang.String articleId,
1247                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1248                    throws com.liferay.portal.kernel.exception.SystemException,
1249                            com.liferay.portlet.journal.NoSuchArticleException {
1250                    return getPersistence()
1251                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
1252                            orderByComparator);
1253            }
1254    
1255            /**
1256            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
1257            *
1258            * @param groupId the group ID
1259            * @param urlTitle the url title
1260            * @return the matching journal articles
1261            * @throws SystemException if a system exception occurred
1262            */
1263            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1264                    long groupId, java.lang.String urlTitle)
1265                    throws com.liferay.portal.kernel.exception.SystemException {
1266                    return getPersistence().findByG_UT(groupId, urlTitle);
1267            }
1268    
1269            /**
1270            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1271            *
1272            * <p>
1273            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1274            * </p>
1275            *
1276            * @param groupId the group ID
1277            * @param urlTitle the url title
1278            * @param start the lower bound of the range of journal articles
1279            * @param end the upper bound of the range of journal articles (not inclusive)
1280            * @return the range of matching journal articles
1281            * @throws SystemException if a system exception occurred
1282            */
1283            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1284                    long groupId, java.lang.String urlTitle, int start, int end)
1285                    throws com.liferay.portal.kernel.exception.SystemException {
1286                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
1287            }
1288    
1289            /**
1290            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1291            *
1292            * <p>
1293            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1294            * </p>
1295            *
1296            * @param groupId the group ID
1297            * @param urlTitle the url title
1298            * @param start the lower bound of the range of journal articles
1299            * @param end the upper bound of the range of journal articles (not inclusive)
1300            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1301            * @return the ordered range of matching journal articles
1302            * @throws SystemException if a system exception occurred
1303            */
1304            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1305                    long groupId, java.lang.String urlTitle, int start, int end,
1306                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1307                    throws com.liferay.portal.kernel.exception.SystemException {
1308                    return getPersistence()
1309                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
1310            }
1311    
1312            /**
1313            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1314            *
1315            * <p>
1316            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1317            * </p>
1318            *
1319            * @param groupId the group ID
1320            * @param urlTitle the url title
1321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1322            * @return the first matching journal article
1323            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1324            * @throws SystemException if a system exception occurred
1325            */
1326            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
1327                    long groupId, java.lang.String urlTitle,
1328                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1329                    throws com.liferay.portal.kernel.exception.SystemException,
1330                            com.liferay.portlet.journal.NoSuchArticleException {
1331                    return getPersistence()
1332                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
1333            }
1334    
1335            /**
1336            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1337            *
1338            * <p>
1339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1340            * </p>
1341            *
1342            * @param groupId the group ID
1343            * @param urlTitle the url title
1344            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1345            * @return the last matching journal article
1346            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1347            * @throws SystemException if a system exception occurred
1348            */
1349            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
1350                    long groupId, java.lang.String urlTitle,
1351                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1352                    throws com.liferay.portal.kernel.exception.SystemException,
1353                            com.liferay.portlet.journal.NoSuchArticleException {
1354                    return getPersistence()
1355                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
1356            }
1357    
1358            /**
1359            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1360            *
1361            * <p>
1362            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1363            * </p>
1364            *
1365            * @param id the primary key of the current journal article
1366            * @param groupId the group ID
1367            * @param urlTitle the url title
1368            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1369            * @return the previous, current, and next journal article
1370            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1371            * @throws SystemException if a system exception occurred
1372            */
1373            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
1374                    long id, long groupId, java.lang.String urlTitle,
1375                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1376                    throws com.liferay.portal.kernel.exception.SystemException,
1377                            com.liferay.portlet.journal.NoSuchArticleException {
1378                    return getPersistence()
1379                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
1380                            orderByComparator);
1381            }
1382    
1383            /**
1384            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1385            *
1386            * @param groupId the group ID
1387            * @param urlTitle the url title
1388            * @return the matching journal articles that the user has permission to view
1389            * @throws SystemException if a system exception occurred
1390            */
1391            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1392                    long groupId, java.lang.String urlTitle)
1393                    throws com.liferay.portal.kernel.exception.SystemException {
1394                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
1395            }
1396    
1397            /**
1398            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1399            *
1400            * <p>
1401            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1402            * </p>
1403            *
1404            * @param groupId the group ID
1405            * @param urlTitle the url title
1406            * @param start the lower bound of the range of journal articles
1407            * @param end the upper bound of the range of journal articles (not inclusive)
1408            * @return the range of matching journal articles that the user has permission to view
1409            * @throws SystemException if a system exception occurred
1410            */
1411            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1412                    long groupId, java.lang.String urlTitle, int start, int end)
1413                    throws com.liferay.portal.kernel.exception.SystemException {
1414                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
1415            }
1416    
1417            /**
1418            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
1419            *
1420            * <p>
1421            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1422            * </p>
1423            *
1424            * @param groupId the group ID
1425            * @param urlTitle the url title
1426            * @param start the lower bound of the range of journal articles
1427            * @param end the upper bound of the range of journal articles (not inclusive)
1428            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1429            * @return the ordered range of matching journal articles that the user has permission to view
1430            * @throws SystemException if a system exception occurred
1431            */
1432            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1433                    long groupId, java.lang.String urlTitle, int start, int end,
1434                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1435                    throws com.liferay.portal.kernel.exception.SystemException {
1436                    return getPersistence()
1437                                       .filterFindByG_UT(groupId, urlTitle, start, end,
1438                            orderByComparator);
1439            }
1440    
1441            /**
1442            * 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;.
1443            *
1444            * @param id the primary key of the current journal article
1445            * @param groupId the group ID
1446            * @param urlTitle the url title
1447            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1448            * @return the previous, current, and next journal article
1449            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1450            * @throws SystemException if a system exception occurred
1451            */
1452            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
1453                    long id, long groupId, java.lang.String urlTitle,
1454                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1455                    throws com.liferay.portal.kernel.exception.SystemException,
1456                            com.liferay.portlet.journal.NoSuchArticleException {
1457                    return getPersistence()
1458                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
1459                            orderByComparator);
1460            }
1461    
1462            /**
1463            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
1464            *
1465            * @param groupId the group ID
1466            * @param structureId the structure ID
1467            * @return the matching journal articles
1468            * @throws SystemException if a system exception occurred
1469            */
1470            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1471                    long groupId, java.lang.String structureId)
1472                    throws com.liferay.portal.kernel.exception.SystemException {
1473                    return getPersistence().findByG_S(groupId, structureId);
1474            }
1475    
1476            /**
1477            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
1478            *
1479            * <p>
1480            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1481            * </p>
1482            *
1483            * @param groupId the group ID
1484            * @param structureId the structure ID
1485            * @param start the lower bound of the range of journal articles
1486            * @param end the upper bound of the range of journal articles (not inclusive)
1487            * @return the range of matching journal articles
1488            * @throws SystemException if a system exception occurred
1489            */
1490            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1491                    long groupId, java.lang.String structureId, int start, int end)
1492                    throws com.liferay.portal.kernel.exception.SystemException {
1493                    return getPersistence().findByG_S(groupId, structureId, start, end);
1494            }
1495    
1496            /**
1497            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
1498            *
1499            * <p>
1500            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1501            * </p>
1502            *
1503            * @param groupId the group ID
1504            * @param structureId the structure ID
1505            * @param start the lower bound of the range of journal articles
1506            * @param end the upper bound of the range of journal articles (not inclusive)
1507            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1508            * @return the ordered range of matching journal articles
1509            * @throws SystemException if a system exception occurred
1510            */
1511            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1512                    long groupId, java.lang.String structureId, int start, int end,
1513                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1514                    throws com.liferay.portal.kernel.exception.SystemException {
1515                    return getPersistence()
1516                                       .findByG_S(groupId, structureId, start, end,
1517                            orderByComparator);
1518            }
1519    
1520            /**
1521            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1522            *
1523            * <p>
1524            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1525            * </p>
1526            *
1527            * @param groupId the group ID
1528            * @param structureId the structure ID
1529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1530            * @return the first matching journal article
1531            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1532            * @throws SystemException if a system exception occurred
1533            */
1534            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
1535                    long groupId, java.lang.String structureId,
1536                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1537                    throws com.liferay.portal.kernel.exception.SystemException,
1538                            com.liferay.portlet.journal.NoSuchArticleException {
1539                    return getPersistence()
1540                                       .findByG_S_First(groupId, structureId, orderByComparator);
1541            }
1542    
1543            /**
1544            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1545            *
1546            * <p>
1547            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1548            * </p>
1549            *
1550            * @param groupId the group ID
1551            * @param structureId the structure ID
1552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1553            * @return the last matching journal article
1554            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1555            * @throws SystemException if a system exception occurred
1556            */
1557            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
1558                    long groupId, java.lang.String structureId,
1559                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1560                    throws com.liferay.portal.kernel.exception.SystemException,
1561                            com.liferay.portlet.journal.NoSuchArticleException {
1562                    return getPersistence()
1563                                       .findByG_S_Last(groupId, structureId, orderByComparator);
1564            }
1565    
1566            /**
1567            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1568            *
1569            * <p>
1570            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1571            * </p>
1572            *
1573            * @param id the primary key of the current journal article
1574            * @param groupId the group ID
1575            * @param structureId the structure ID
1576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1577            * @return the previous, current, and next journal article
1578            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1579            * @throws SystemException if a system exception occurred
1580            */
1581            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
1582                    long id, long groupId, java.lang.String structureId,
1583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1584                    throws com.liferay.portal.kernel.exception.SystemException,
1585                            com.liferay.portlet.journal.NoSuchArticleException {
1586                    return getPersistence()
1587                                       .findByG_S_PrevAndNext(id, groupId, structureId,
1588                            orderByComparator);
1589            }
1590    
1591            /**
1592            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1593            *
1594            * @param groupId the group ID
1595            * @param structureId the structure ID
1596            * @return the matching journal articles that the user has permission to view
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1600                    long groupId, java.lang.String structureId)
1601                    throws com.liferay.portal.kernel.exception.SystemException {
1602                    return getPersistence().filterFindByG_S(groupId, structureId);
1603            }
1604    
1605            /**
1606            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1607            *
1608            * <p>
1609            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1610            * </p>
1611            *
1612            * @param groupId the group ID
1613            * @param structureId the structure ID
1614            * @param start the lower bound of the range of journal articles
1615            * @param end the upper bound of the range of journal articles (not inclusive)
1616            * @return the range of matching journal articles that the user has permission to view
1617            * @throws SystemException if a system exception occurred
1618            */
1619            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1620                    long groupId, java.lang.String structureId, int start, int end)
1621                    throws com.liferay.portal.kernel.exception.SystemException {
1622                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
1623            }
1624    
1625            /**
1626            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
1627            *
1628            * <p>
1629            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1630            * </p>
1631            *
1632            * @param groupId the group ID
1633            * @param structureId the structure ID
1634            * @param start the lower bound of the range of journal articles
1635            * @param end the upper bound of the range of journal articles (not inclusive)
1636            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1637            * @return the ordered range of matching journal articles that the user has permission to view
1638            * @throws SystemException if a system exception occurred
1639            */
1640            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1641                    long groupId, java.lang.String structureId, int start, int end,
1642                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1643                    throws com.liferay.portal.kernel.exception.SystemException {
1644                    return getPersistence()
1645                                       .filterFindByG_S(groupId, structureId, start, end,
1646                            orderByComparator);
1647            }
1648    
1649            /**
1650            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1651            *
1652            * @param id the primary key of the current journal article
1653            * @param groupId the group ID
1654            * @param structureId the structure ID
1655            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1656            * @return the previous, current, and next journal article
1657            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1658            * @throws SystemException if a system exception occurred
1659            */
1660            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
1661                    long id, long groupId, java.lang.String structureId,
1662                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1663                    throws com.liferay.portal.kernel.exception.SystemException,
1664                            com.liferay.portlet.journal.NoSuchArticleException {
1665                    return getPersistence()
1666                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
1667                            orderByComparator);
1668            }
1669    
1670            /**
1671            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
1672            *
1673            * @param groupId the group ID
1674            * @param templateId the template ID
1675            * @return the matching journal articles
1676            * @throws SystemException if a system exception occurred
1677            */
1678            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1679                    long groupId, java.lang.String templateId)
1680                    throws com.liferay.portal.kernel.exception.SystemException {
1681                    return getPersistence().findByG_T(groupId, templateId);
1682            }
1683    
1684            /**
1685            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
1686            *
1687            * <p>
1688            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1689            * </p>
1690            *
1691            * @param groupId the group ID
1692            * @param templateId the template ID
1693            * @param start the lower bound of the range of journal articles
1694            * @param end the upper bound of the range of journal articles (not inclusive)
1695            * @return the range of matching journal articles
1696            * @throws SystemException if a system exception occurred
1697            */
1698            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1699                    long groupId, java.lang.String templateId, int start, int end)
1700                    throws com.liferay.portal.kernel.exception.SystemException {
1701                    return getPersistence().findByG_T(groupId, templateId, start, end);
1702            }
1703    
1704            /**
1705            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
1706            *
1707            * <p>
1708            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1709            * </p>
1710            *
1711            * @param groupId the group ID
1712            * @param templateId the template ID
1713            * @param start the lower bound of the range of journal articles
1714            * @param end the upper bound of the range of journal articles (not inclusive)
1715            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1716            * @return the ordered range of matching journal articles
1717            * @throws SystemException if a system exception occurred
1718            */
1719            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1720                    long groupId, java.lang.String templateId, int start, int end,
1721                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1722                    throws com.liferay.portal.kernel.exception.SystemException {
1723                    return getPersistence()
1724                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
1725            }
1726    
1727            /**
1728            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1729            *
1730            * <p>
1731            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1732            * </p>
1733            *
1734            * @param groupId the group ID
1735            * @param templateId the template ID
1736            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1737            * @return the first matching journal article
1738            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1739            * @throws SystemException if a system exception occurred
1740            */
1741            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
1742                    long groupId, java.lang.String templateId,
1743                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1744                    throws com.liferay.portal.kernel.exception.SystemException,
1745                            com.liferay.portlet.journal.NoSuchArticleException {
1746                    return getPersistence()
1747                                       .findByG_T_First(groupId, templateId, orderByComparator);
1748            }
1749    
1750            /**
1751            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1752            *
1753            * <p>
1754            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1755            * </p>
1756            *
1757            * @param groupId the group ID
1758            * @param templateId the template ID
1759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1760            * @return the last matching journal article
1761            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1762            * @throws SystemException if a system exception occurred
1763            */
1764            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
1765                    long groupId, java.lang.String templateId,
1766                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1767                    throws com.liferay.portal.kernel.exception.SystemException,
1768                            com.liferay.portlet.journal.NoSuchArticleException {
1769                    return getPersistence()
1770                                       .findByG_T_Last(groupId, templateId, orderByComparator);
1771            }
1772    
1773            /**
1774            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1775            *
1776            * <p>
1777            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1778            * </p>
1779            *
1780            * @param id the primary key of the current journal article
1781            * @param groupId the group ID
1782            * @param templateId the template ID
1783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1784            * @return the previous, current, and next journal article
1785            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1786            * @throws SystemException if a system exception occurred
1787            */
1788            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
1789                    long id, long groupId, java.lang.String templateId,
1790                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1791                    throws com.liferay.portal.kernel.exception.SystemException,
1792                            com.liferay.portlet.journal.NoSuchArticleException {
1793                    return getPersistence()
1794                                       .findByG_T_PrevAndNext(id, groupId, templateId,
1795                            orderByComparator);
1796            }
1797    
1798            /**
1799            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
1800            *
1801            * @param groupId the group ID
1802            * @param templateId the template ID
1803            * @return the matching journal articles that the user has permission to view
1804            * @throws SystemException if a system exception occurred
1805            */
1806            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1807                    long groupId, java.lang.String templateId)
1808                    throws com.liferay.portal.kernel.exception.SystemException {
1809                    return getPersistence().filterFindByG_T(groupId, templateId);
1810            }
1811    
1812            /**
1813            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
1814            *
1815            * <p>
1816            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1817            * </p>
1818            *
1819            * @param groupId the group ID
1820            * @param templateId the template ID
1821            * @param start the lower bound of the range of journal articles
1822            * @param end the upper bound of the range of journal articles (not inclusive)
1823            * @return the range of matching journal articles that the user has permission to view
1824            * @throws SystemException if a system exception occurred
1825            */
1826            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1827                    long groupId, java.lang.String templateId, int start, int end)
1828                    throws com.liferay.portal.kernel.exception.SystemException {
1829                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
1830            }
1831    
1832            /**
1833            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
1834            *
1835            * <p>
1836            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1837            * </p>
1838            *
1839            * @param groupId the group ID
1840            * @param templateId the template ID
1841            * @param start the lower bound of the range of journal articles
1842            * @param end the upper bound of the range of journal articles (not inclusive)
1843            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1844            * @return the ordered range of matching journal articles that the user has permission to view
1845            * @throws SystemException if a system exception occurred
1846            */
1847            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
1848                    long groupId, java.lang.String templateId, int start, int end,
1849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1850                    throws com.liferay.portal.kernel.exception.SystemException {
1851                    return getPersistence()
1852                                       .filterFindByG_T(groupId, templateId, start, end,
1853                            orderByComparator);
1854            }
1855    
1856            /**
1857            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
1858            *
1859            * @param id the primary key of the current journal article
1860            * @param groupId the group ID
1861            * @param templateId the template ID
1862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1863            * @return the previous, current, and next journal article
1864            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1865            * @throws SystemException if a system exception occurred
1866            */
1867            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
1868                    long id, long groupId, java.lang.String templateId,
1869                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1870                    throws com.liferay.portal.kernel.exception.SystemException,
1871                            com.liferay.portlet.journal.NoSuchArticleException {
1872                    return getPersistence()
1873                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
1874                            orderByComparator);
1875            }
1876    
1877            /**
1878            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
1879            *
1880            * @param groupId the group ID
1881            * @param layoutUuid the layout uuid
1882            * @return the matching journal articles
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
1886                    long groupId, java.lang.String layoutUuid)
1887                    throws com.liferay.portal.kernel.exception.SystemException {
1888                    return getPersistence().findByG_L(groupId, layoutUuid);
1889            }
1890    
1891            /**
1892            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
1893            *
1894            * <p>
1895            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1896            * </p>
1897            *
1898            * @param groupId the group ID
1899            * @param layoutUuid the layout uuid
1900            * @param start the lower bound of the range of journal articles
1901            * @param end the upper bound of the range of journal articles (not inclusive)
1902            * @return the range of matching journal articles
1903            * @throws SystemException if a system exception occurred
1904            */
1905            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
1906                    long groupId, java.lang.String layoutUuid, int start, int end)
1907                    throws com.liferay.portal.kernel.exception.SystemException {
1908                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
1909            }
1910    
1911            /**
1912            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
1913            *
1914            * <p>
1915            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1916            * </p>
1917            *
1918            * @param groupId the group ID
1919            * @param layoutUuid the layout uuid
1920            * @param start the lower bound of the range of journal articles
1921            * @param end the upper bound of the range of journal articles (not inclusive)
1922            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1923            * @return the ordered range of matching journal articles
1924            * @throws SystemException if a system exception occurred
1925            */
1926            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
1927                    long groupId, java.lang.String layoutUuid, int start, int end,
1928                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1929                    throws com.liferay.portal.kernel.exception.SystemException {
1930                    return getPersistence()
1931                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
1932            }
1933    
1934            /**
1935            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
1936            *
1937            * <p>
1938            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1939            * </p>
1940            *
1941            * @param groupId the group ID
1942            * @param layoutUuid the layout uuid
1943            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1944            * @return the first matching journal article
1945            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1946            * @throws SystemException if a system exception occurred
1947            */
1948            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
1949                    long groupId, java.lang.String layoutUuid,
1950                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1951                    throws com.liferay.portal.kernel.exception.SystemException,
1952                            com.liferay.portlet.journal.NoSuchArticleException {
1953                    return getPersistence()
1954                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
1955            }
1956    
1957            /**
1958            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
1959            *
1960            * <p>
1961            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1962            * </p>
1963            *
1964            * @param groupId the group ID
1965            * @param layoutUuid the layout uuid
1966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1967            * @return the last matching journal article
1968            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1969            * @throws SystemException if a system exception occurred
1970            */
1971            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
1972                    long groupId, java.lang.String layoutUuid,
1973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1974                    throws com.liferay.portal.kernel.exception.SystemException,
1975                            com.liferay.portlet.journal.NoSuchArticleException {
1976                    return getPersistence()
1977                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
1978            }
1979    
1980            /**
1981            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
1982            *
1983            * <p>
1984            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1985            * </p>
1986            *
1987            * @param id the primary key of the current journal article
1988            * @param groupId the group ID
1989            * @param layoutUuid the layout uuid
1990            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1991            * @return the previous, current, and next journal article
1992            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1993            * @throws SystemException if a system exception occurred
1994            */
1995            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
1996                    long id, long groupId, java.lang.String layoutUuid,
1997                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1998                    throws com.liferay.portal.kernel.exception.SystemException,
1999                            com.liferay.portlet.journal.NoSuchArticleException {
2000                    return getPersistence()
2001                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
2002                            orderByComparator);
2003            }
2004    
2005            /**
2006            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2007            *
2008            * @param groupId the group ID
2009            * @param layoutUuid the layout uuid
2010            * @return the matching journal articles that the user has permission to view
2011            * @throws SystemException if a system exception occurred
2012            */
2013            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2014                    long groupId, java.lang.String layoutUuid)
2015                    throws com.liferay.portal.kernel.exception.SystemException {
2016                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
2017            }
2018    
2019            /**
2020            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2021            *
2022            * <p>
2023            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2024            * </p>
2025            *
2026            * @param groupId the group ID
2027            * @param layoutUuid the layout uuid
2028            * @param start the lower bound of the range of journal articles
2029            * @param end the upper bound of the range of journal articles (not inclusive)
2030            * @return the range of matching journal articles that the user has permission to view
2031            * @throws SystemException if a system exception occurred
2032            */
2033            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2034                    long groupId, java.lang.String layoutUuid, int start, int end)
2035                    throws com.liferay.portal.kernel.exception.SystemException {
2036                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
2037            }
2038    
2039            /**
2040            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
2041            *
2042            * <p>
2043            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2044            * </p>
2045            *
2046            * @param groupId the group ID
2047            * @param layoutUuid the layout uuid
2048            * @param start the lower bound of the range of journal articles
2049            * @param end the upper bound of the range of journal articles (not inclusive)
2050            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2051            * @return the ordered range of matching journal articles that the user has permission to view
2052            * @throws SystemException if a system exception occurred
2053            */
2054            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2055                    long groupId, java.lang.String layoutUuid, int start, int end,
2056                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2057                    throws com.liferay.portal.kernel.exception.SystemException {
2058                    return getPersistence()
2059                                       .filterFindByG_L(groupId, layoutUuid, start, end,
2060                            orderByComparator);
2061            }
2062    
2063            /**
2064            * 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;.
2065            *
2066            * @param id the primary key of the current journal article
2067            * @param groupId the group ID
2068            * @param layoutUuid the layout uuid
2069            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2070            * @return the previous, current, and next journal article
2071            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2072            * @throws SystemException if a system exception occurred
2073            */
2074            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
2075                    long id, long groupId, java.lang.String layoutUuid,
2076                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2077                    throws com.liferay.portal.kernel.exception.SystemException,
2078                            com.liferay.portlet.journal.NoSuchArticleException {
2079                    return getPersistence()
2080                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
2081                            orderByComparator);
2082            }
2083    
2084            /**
2085            * Returns all the journal articles where groupId = &#63; and status = &#63;.
2086            *
2087            * @param groupId the group ID
2088            * @param status the status
2089            * @return the matching journal articles
2090            * @throws SystemException if a system exception occurred
2091            */
2092            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2093                    long groupId, int status)
2094                    throws com.liferay.portal.kernel.exception.SystemException {
2095                    return getPersistence().findByG_ST(groupId, status);
2096            }
2097    
2098            /**
2099            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
2100            *
2101            * <p>
2102            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2103            * </p>
2104            *
2105            * @param groupId the group ID
2106            * @param status the status
2107            * @param start the lower bound of the range of journal articles
2108            * @param end the upper bound of the range of journal articles (not inclusive)
2109            * @return the range of matching journal articles
2110            * @throws SystemException if a system exception occurred
2111            */
2112            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2113                    long groupId, int status, int start, int end)
2114                    throws com.liferay.portal.kernel.exception.SystemException {
2115                    return getPersistence().findByG_ST(groupId, status, start, end);
2116            }
2117    
2118            /**
2119            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
2120            *
2121            * <p>
2122            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2123            * </p>
2124            *
2125            * @param groupId the group ID
2126            * @param status the status
2127            * @param start the lower bound of the range of journal articles
2128            * @param end the upper bound of the range of journal articles (not inclusive)
2129            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2130            * @return the ordered range of matching journal articles
2131            * @throws SystemException if a system exception occurred
2132            */
2133            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2134                    long groupId, int status, int start, int end,
2135                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2136                    throws com.liferay.portal.kernel.exception.SystemException {
2137                    return getPersistence()
2138                                       .findByG_ST(groupId, status, start, end, orderByComparator);
2139            }
2140    
2141            /**
2142            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
2143            *
2144            * <p>
2145            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2146            * </p>
2147            *
2148            * @param groupId the group ID
2149            * @param status the status
2150            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2151            * @return the first matching journal article
2152            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2153            * @throws SystemException if a system exception occurred
2154            */
2155            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
2156                    long groupId, int status,
2157                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2158                    throws com.liferay.portal.kernel.exception.SystemException,
2159                            com.liferay.portlet.journal.NoSuchArticleException {
2160                    return getPersistence()
2161                                       .findByG_ST_First(groupId, status, orderByComparator);
2162            }
2163    
2164            /**
2165            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
2166            *
2167            * <p>
2168            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2169            * </p>
2170            *
2171            * @param groupId the group ID
2172            * @param status the status
2173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2174            * @return the last matching journal article
2175            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2176            * @throws SystemException if a system exception occurred
2177            */
2178            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
2179                    long groupId, int status,
2180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2181                    throws com.liferay.portal.kernel.exception.SystemException,
2182                            com.liferay.portlet.journal.NoSuchArticleException {
2183                    return getPersistence()
2184                                       .findByG_ST_Last(groupId, status, orderByComparator);
2185            }
2186    
2187            /**
2188            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
2189            *
2190            * <p>
2191            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2192            * </p>
2193            *
2194            * @param id the primary key of the current journal article
2195            * @param groupId the group ID
2196            * @param status the status
2197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2198            * @return the previous, current, and next journal article
2199            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2200            * @throws SystemException if a system exception occurred
2201            */
2202            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
2203                    long id, long groupId, int status,
2204                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2205                    throws com.liferay.portal.kernel.exception.SystemException,
2206                            com.liferay.portlet.journal.NoSuchArticleException {
2207                    return getPersistence()
2208                                       .findByG_ST_PrevAndNext(id, groupId, status,
2209                            orderByComparator);
2210            }
2211    
2212            /**
2213            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2214            *
2215            * @param groupId the group ID
2216            * @param status the status
2217            * @return the matching journal articles that the user has permission to view
2218            * @throws SystemException if a system exception occurred
2219            */
2220            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2221                    long groupId, int status)
2222                    throws com.liferay.portal.kernel.exception.SystemException {
2223                    return getPersistence().filterFindByG_ST(groupId, status);
2224            }
2225    
2226            /**
2227            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2228            *
2229            * <p>
2230            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2231            * </p>
2232            *
2233            * @param groupId the group ID
2234            * @param status the status
2235            * @param start the lower bound of the range of journal articles
2236            * @param end the upper bound of the range of journal articles (not inclusive)
2237            * @return the range of matching journal articles that the user has permission to view
2238            * @throws SystemException if a system exception occurred
2239            */
2240            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2241                    long groupId, int status, int start, int end)
2242                    throws com.liferay.portal.kernel.exception.SystemException {
2243                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
2244            }
2245    
2246            /**
2247            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
2248            *
2249            * <p>
2250            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2251            * </p>
2252            *
2253            * @param groupId the group ID
2254            * @param status the status
2255            * @param start the lower bound of the range of journal articles
2256            * @param end the upper bound of the range of journal articles (not inclusive)
2257            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2258            * @return the ordered range of matching journal articles that the user has permission to view
2259            * @throws SystemException if a system exception occurred
2260            */
2261            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2262                    long groupId, int status, int start, int end,
2263                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2264                    throws com.liferay.portal.kernel.exception.SystemException {
2265                    return getPersistence()
2266                                       .filterFindByG_ST(groupId, status, start, end,
2267                            orderByComparator);
2268            }
2269    
2270            /**
2271            * 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;.
2272            *
2273            * @param id the primary key of the current journal article
2274            * @param groupId the group ID
2275            * @param status the status
2276            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2277            * @return the previous, current, and next journal article
2278            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2279            * @throws SystemException if a system exception occurred
2280            */
2281            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
2282                    long id, long groupId, int status,
2283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2284                    throws com.liferay.portal.kernel.exception.SystemException,
2285                            com.liferay.portlet.journal.NoSuchArticleException {
2286                    return getPersistence()
2287                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
2288                            orderByComparator);
2289            }
2290    
2291            /**
2292            * Returns all the journal articles where companyId = &#63; and version = &#63;.
2293            *
2294            * @param companyId the company ID
2295            * @param version the version
2296            * @return the matching journal articles
2297            * @throws SystemException if a system exception occurred
2298            */
2299            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2300                    long companyId, double version)
2301                    throws com.liferay.portal.kernel.exception.SystemException {
2302                    return getPersistence().findByC_V(companyId, version);
2303            }
2304    
2305            /**
2306            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
2307            *
2308            * <p>
2309            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2310            * </p>
2311            *
2312            * @param companyId the company ID
2313            * @param version the version
2314            * @param start the lower bound of the range of journal articles
2315            * @param end the upper bound of the range of journal articles (not inclusive)
2316            * @return the range of matching journal articles
2317            * @throws SystemException if a system exception occurred
2318            */
2319            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2320                    long companyId, double version, int start, int end)
2321                    throws com.liferay.portal.kernel.exception.SystemException {
2322                    return getPersistence().findByC_V(companyId, version, start, end);
2323            }
2324    
2325            /**
2326            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
2327            *
2328            * <p>
2329            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2330            * </p>
2331            *
2332            * @param companyId the company ID
2333            * @param version the version
2334            * @param start the lower bound of the range of journal articles
2335            * @param end the upper bound of the range of journal articles (not inclusive)
2336            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2337            * @return the ordered range of matching journal articles
2338            * @throws SystemException if a system exception occurred
2339            */
2340            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2341                    long companyId, double version, int start, int end,
2342                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2343                    throws com.liferay.portal.kernel.exception.SystemException {
2344                    return getPersistence()
2345                                       .findByC_V(companyId, version, start, end, orderByComparator);
2346            }
2347    
2348            /**
2349            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
2350            *
2351            * <p>
2352            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2353            * </p>
2354            *
2355            * @param companyId the company ID
2356            * @param version the version
2357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2358            * @return the first matching journal article
2359            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2360            * @throws SystemException if a system exception occurred
2361            */
2362            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
2363                    long companyId, double version,
2364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2365                    throws com.liferay.portal.kernel.exception.SystemException,
2366                            com.liferay.portlet.journal.NoSuchArticleException {
2367                    return getPersistence()
2368                                       .findByC_V_First(companyId, version, orderByComparator);
2369            }
2370    
2371            /**
2372            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
2373            *
2374            * <p>
2375            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2376            * </p>
2377            *
2378            * @param companyId the company ID
2379            * @param version the version
2380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2381            * @return the last matching journal article
2382            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2383            * @throws SystemException if a system exception occurred
2384            */
2385            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
2386                    long companyId, double version,
2387                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2388                    throws com.liferay.portal.kernel.exception.SystemException,
2389                            com.liferay.portlet.journal.NoSuchArticleException {
2390                    return getPersistence()
2391                                       .findByC_V_Last(companyId, version, orderByComparator);
2392            }
2393    
2394            /**
2395            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
2396            *
2397            * <p>
2398            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2399            * </p>
2400            *
2401            * @param id the primary key of the current journal article
2402            * @param companyId the company ID
2403            * @param version the version
2404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2405            * @return the previous, current, and next journal article
2406            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2407            * @throws SystemException if a system exception occurred
2408            */
2409            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
2410                    long id, long companyId, double version,
2411                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2412                    throws com.liferay.portal.kernel.exception.SystemException,
2413                            com.liferay.portlet.journal.NoSuchArticleException {
2414                    return getPersistence()
2415                                       .findByC_V_PrevAndNext(id, companyId, version,
2416                            orderByComparator);
2417            }
2418    
2419            /**
2420            * Returns all the journal articles where companyId = &#63; and status = &#63;.
2421            *
2422            * @param companyId the company ID
2423            * @param status the status
2424            * @return the matching journal articles
2425            * @throws SystemException if a system exception occurred
2426            */
2427            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2428                    long companyId, int status)
2429                    throws com.liferay.portal.kernel.exception.SystemException {
2430                    return getPersistence().findByC_ST(companyId, status);
2431            }
2432    
2433            /**
2434            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
2435            *
2436            * <p>
2437            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2438            * </p>
2439            *
2440            * @param companyId the company ID
2441            * @param status the status
2442            * @param start the lower bound of the range of journal articles
2443            * @param end the upper bound of the range of journal articles (not inclusive)
2444            * @return the range of matching journal articles
2445            * @throws SystemException if a system exception occurred
2446            */
2447            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2448                    long companyId, int status, int start, int end)
2449                    throws com.liferay.portal.kernel.exception.SystemException {
2450                    return getPersistence().findByC_ST(companyId, status, start, end);
2451            }
2452    
2453            /**
2454            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
2455            *
2456            * <p>
2457            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2458            * </p>
2459            *
2460            * @param companyId the company ID
2461            * @param status the status
2462            * @param start the lower bound of the range of journal articles
2463            * @param end the upper bound of the range of journal articles (not inclusive)
2464            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2465            * @return the ordered range of matching journal articles
2466            * @throws SystemException if a system exception occurred
2467            */
2468            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2469                    long companyId, int status, int start, int end,
2470                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2471                    throws com.liferay.portal.kernel.exception.SystemException {
2472                    return getPersistence()
2473                                       .findByC_ST(companyId, status, start, end, orderByComparator);
2474            }
2475    
2476            /**
2477            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
2478            *
2479            * <p>
2480            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2481            * </p>
2482            *
2483            * @param companyId the company ID
2484            * @param status the status
2485            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2486            * @return the first matching journal article
2487            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2488            * @throws SystemException if a system exception occurred
2489            */
2490            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
2491                    long companyId, int status,
2492                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2493                    throws com.liferay.portal.kernel.exception.SystemException,
2494                            com.liferay.portlet.journal.NoSuchArticleException {
2495                    return getPersistence()
2496                                       .findByC_ST_First(companyId, status, orderByComparator);
2497            }
2498    
2499            /**
2500            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
2501            *
2502            * <p>
2503            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2504            * </p>
2505            *
2506            * @param companyId the company ID
2507            * @param status the status
2508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2509            * @return the last matching journal article
2510            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2511            * @throws SystemException if a system exception occurred
2512            */
2513            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
2514                    long companyId, int status,
2515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2516                    throws com.liferay.portal.kernel.exception.SystemException,
2517                            com.liferay.portlet.journal.NoSuchArticleException {
2518                    return getPersistence()
2519                                       .findByC_ST_Last(companyId, status, orderByComparator);
2520            }
2521    
2522            /**
2523            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
2524            *
2525            * <p>
2526            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2527            * </p>
2528            *
2529            * @param id the primary key of the current journal article
2530            * @param companyId the company ID
2531            * @param status the status
2532            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2533            * @return the previous, current, and next journal article
2534            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2535            * @throws SystemException if a system exception occurred
2536            */
2537            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
2538                    long id, long companyId, int status,
2539                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2540                    throws com.liferay.portal.kernel.exception.SystemException,
2541                            com.liferay.portlet.journal.NoSuchArticleException {
2542                    return getPersistence()
2543                                       .findByC_ST_PrevAndNext(id, companyId, status,
2544                            orderByComparator);
2545            }
2546    
2547            /**
2548            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2549            *
2550            * @param groupId the group ID
2551            * @param classNameId the class name ID
2552            * @param classPK the class p k
2553            * @return the matching journal articles
2554            * @throws SystemException if a system exception occurred
2555            */
2556            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2557                    long groupId, long classNameId, long classPK)
2558                    throws com.liferay.portal.kernel.exception.SystemException {
2559                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
2560            }
2561    
2562            /**
2563            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2564            *
2565            * <p>
2566            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2567            * </p>
2568            *
2569            * @param groupId the group ID
2570            * @param classNameId the class name ID
2571            * @param classPK the class p k
2572            * @param start the lower bound of the range of journal articles
2573            * @param end the upper bound of the range of journal articles (not inclusive)
2574            * @return the range of matching journal articles
2575            * @throws SystemException if a system exception occurred
2576            */
2577            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2578                    long groupId, long classNameId, long classPK, int start, int end)
2579                    throws com.liferay.portal.kernel.exception.SystemException {
2580                    return getPersistence()
2581                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
2582            }
2583    
2584            /**
2585            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2586            *
2587            * <p>
2588            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2589            * </p>
2590            *
2591            * @param groupId the group ID
2592            * @param classNameId the class name ID
2593            * @param classPK the class p k
2594            * @param start the lower bound of the range of journal articles
2595            * @param end the upper bound of the range of journal articles (not inclusive)
2596            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2597            * @return the ordered range of matching journal articles
2598            * @throws SystemException if a system exception occurred
2599            */
2600            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2601                    long groupId, long classNameId, long classPK, int start, int end,
2602                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2603                    throws com.liferay.portal.kernel.exception.SystemException {
2604                    return getPersistence()
2605                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
2606                            orderByComparator);
2607            }
2608    
2609            /**
2610            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2611            *
2612            * <p>
2613            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2614            * </p>
2615            *
2616            * @param groupId the group ID
2617            * @param classNameId the class name ID
2618            * @param classPK the class p k
2619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2620            * @return the first matching journal article
2621            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2622            * @throws SystemException if a system exception occurred
2623            */
2624            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
2625                    long groupId, long classNameId, long classPK,
2626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2627                    throws com.liferay.portal.kernel.exception.SystemException,
2628                            com.liferay.portlet.journal.NoSuchArticleException {
2629                    return getPersistence()
2630                                       .findByG_C_C_First(groupId, classNameId, classPK,
2631                            orderByComparator);
2632            }
2633    
2634            /**
2635            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2636            *
2637            * <p>
2638            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2639            * </p>
2640            *
2641            * @param groupId the group ID
2642            * @param classNameId the class name ID
2643            * @param classPK the class p k
2644            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2645            * @return the last matching journal article
2646            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2647            * @throws SystemException if a system exception occurred
2648            */
2649            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
2650                    long groupId, long classNameId, long classPK,
2651                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2652                    throws com.liferay.portal.kernel.exception.SystemException,
2653                            com.liferay.portlet.journal.NoSuchArticleException {
2654                    return getPersistence()
2655                                       .findByG_C_C_Last(groupId, classNameId, classPK,
2656                            orderByComparator);
2657            }
2658    
2659            /**
2660            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2661            *
2662            * <p>
2663            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2664            * </p>
2665            *
2666            * @param id the primary key of the current journal article
2667            * @param groupId the group ID
2668            * @param classNameId the class name ID
2669            * @param classPK the class p k
2670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2671            * @return the previous, current, and next journal article
2672            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2673            * @throws SystemException if a system exception occurred
2674            */
2675            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
2676                    long id, long groupId, long classNameId, long classPK,
2677                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2678                    throws com.liferay.portal.kernel.exception.SystemException,
2679                            com.liferay.portlet.journal.NoSuchArticleException {
2680                    return getPersistence()
2681                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
2682                            orderByComparator);
2683            }
2684    
2685            /**
2686            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2687            *
2688            * @param groupId the group ID
2689            * @param classNameId the class name ID
2690            * @param classPK the class p k
2691            * @return the matching journal articles that the user has permission to view
2692            * @throws SystemException if a system exception occurred
2693            */
2694            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2695                    long groupId, long classNameId, long classPK)
2696                    throws com.liferay.portal.kernel.exception.SystemException {
2697                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
2698            }
2699    
2700            /**
2701            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2702            *
2703            * <p>
2704            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2705            * </p>
2706            *
2707            * @param groupId the group ID
2708            * @param classNameId the class name ID
2709            * @param classPK the class p k
2710            * @param start the lower bound of the range of journal articles
2711            * @param end the upper bound of the range of journal articles (not inclusive)
2712            * @return the range of matching journal articles that the user has permission to view
2713            * @throws SystemException if a system exception occurred
2714            */
2715            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2716                    long groupId, long classNameId, long classPK, int start, int end)
2717                    throws com.liferay.portal.kernel.exception.SystemException {
2718                    return getPersistence()
2719                                       .filterFindByG_C_C(groupId, classNameId, classPK, 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 classNameId = &#63; and classPK = &#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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2727            * </p>
2728            *
2729            * @param groupId the group ID
2730            * @param classNameId the class name ID
2731            * @param classPK the class p k
2732            * @param start the lower bound of the range of journal articles
2733            * @param end the upper bound of the range of journal articles (not inclusive)
2734            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2735            * @return the ordered range of matching journal articles that the user has permission to view
2736            * @throws SystemException if a system exception occurred
2737            */
2738            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2739                    long groupId, long classNameId, long classPK, int start, int end,
2740                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2741                    throws com.liferay.portal.kernel.exception.SystemException {
2742                    return getPersistence()
2743                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
2744                            end, orderByComparator);
2745            }
2746    
2747            /**
2748            * 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;.
2749            *
2750            * @param id the primary key of the current journal article
2751            * @param groupId the group ID
2752            * @param classNameId the class name ID
2753            * @param classPK the class p k
2754            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2755            * @return the previous, current, and next journal article
2756            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2757            * @throws SystemException if a system exception occurred
2758            */
2759            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
2760                    long id, long groupId, long classNameId, long classPK,
2761                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2762                    throws com.liferay.portal.kernel.exception.SystemException,
2763                            com.liferay.portlet.journal.NoSuchArticleException {
2764                    return getPersistence()
2765                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
2766                            classPK, orderByComparator);
2767            }
2768    
2769            /**
2770            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
2771            *
2772            * @param groupId the group ID
2773            * @param classNameId the class name ID
2774            * @param structureId the structure ID
2775            * @return the matching journal article
2776            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2777            * @throws SystemException if a system exception occurred
2778            */
2779            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
2780                    long groupId, long classNameId, java.lang.String structureId)
2781                    throws com.liferay.portal.kernel.exception.SystemException,
2782                            com.liferay.portlet.journal.NoSuchArticleException {
2783                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
2784            }
2785    
2786            /**
2787            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2788            *
2789            * @param groupId the group ID
2790            * @param classNameId the class name ID
2791            * @param structureId the structure ID
2792            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
2793            * @throws SystemException if a system exception occurred
2794            */
2795            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
2796                    long groupId, long classNameId, java.lang.String structureId)
2797                    throws com.liferay.portal.kernel.exception.SystemException {
2798                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
2799            }
2800    
2801            /**
2802            * Returns the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2803            *
2804            * @param groupId the group ID
2805            * @param classNameId the class name ID
2806            * @param structureId the structure ID
2807            * @param retrieveFromCache whether to use the finder cache
2808            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
2809            * @throws SystemException if a system exception occurred
2810            */
2811            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
2812                    long groupId, long classNameId, java.lang.String structureId,
2813                    boolean retrieveFromCache)
2814                    throws com.liferay.portal.kernel.exception.SystemException {
2815                    return getPersistence()
2816                                       .fetchByG_C_S(groupId, classNameId, structureId,
2817                            retrieveFromCache);
2818            }
2819    
2820            /**
2821            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2822            *
2823            * @param groupId the group ID
2824            * @param classNameId the class name ID
2825            * @param templateId the template ID
2826            * @return the matching journal articles
2827            * @throws SystemException if a system exception occurred
2828            */
2829            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
2830                    long groupId, long classNameId, java.lang.String templateId)
2831                    throws com.liferay.portal.kernel.exception.SystemException {
2832                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
2833            }
2834    
2835            /**
2836            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2837            *
2838            * <p>
2839            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2840            * </p>
2841            *
2842            * @param groupId the group ID
2843            * @param classNameId the class name ID
2844            * @param templateId the template ID
2845            * @param start the lower bound of the range of journal articles
2846            * @param end the upper bound of the range of journal articles (not inclusive)
2847            * @return the range of matching journal articles
2848            * @throws SystemException if a system exception occurred
2849            */
2850            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
2851                    long groupId, long classNameId, java.lang.String templateId, int start,
2852                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2853                    return getPersistence()
2854                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
2855            }
2856    
2857            /**
2858            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2859            *
2860            * <p>
2861            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2862            * </p>
2863            *
2864            * @param groupId the group ID
2865            * @param classNameId the class name ID
2866            * @param templateId the template ID
2867            * @param start the lower bound of the range of journal articles
2868            * @param end the upper bound of the range of journal articles (not inclusive)
2869            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2870            * @return the ordered range of matching journal articles
2871            * @throws SystemException if a system exception occurred
2872            */
2873            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
2874                    long groupId, long classNameId, java.lang.String templateId, int start,
2875                    int end,
2876                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2877                    throws com.liferay.portal.kernel.exception.SystemException {
2878                    return getPersistence()
2879                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
2880                            orderByComparator);
2881            }
2882    
2883            /**
2884            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2885            *
2886            * <p>
2887            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2888            * </p>
2889            *
2890            * @param groupId the group ID
2891            * @param classNameId the class name ID
2892            * @param templateId the template ID
2893            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2894            * @return the first matching journal article
2895            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2896            * @throws SystemException if a system exception occurred
2897            */
2898            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
2899                    long groupId, long classNameId, java.lang.String templateId,
2900                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2901                    throws com.liferay.portal.kernel.exception.SystemException,
2902                            com.liferay.portlet.journal.NoSuchArticleException {
2903                    return getPersistence()
2904                                       .findByG_C_T_First(groupId, classNameId, templateId,
2905                            orderByComparator);
2906            }
2907    
2908            /**
2909            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2910            *
2911            * <p>
2912            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2913            * </p>
2914            *
2915            * @param groupId the group ID
2916            * @param classNameId the class name ID
2917            * @param templateId the template ID
2918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2919            * @return the last matching journal article
2920            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2921            * @throws SystemException if a system exception occurred
2922            */
2923            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
2924                    long groupId, long classNameId, java.lang.String templateId,
2925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2926                    throws com.liferay.portal.kernel.exception.SystemException,
2927                            com.liferay.portlet.journal.NoSuchArticleException {
2928                    return getPersistence()
2929                                       .findByG_C_T_Last(groupId, classNameId, templateId,
2930                            orderByComparator);
2931            }
2932    
2933            /**
2934            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2935            *
2936            * <p>
2937            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2938            * </p>
2939            *
2940            * @param id the primary key of the current journal article
2941            * @param groupId the group ID
2942            * @param classNameId the class name ID
2943            * @param templateId the template ID
2944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2945            * @return the previous, current, and next journal article
2946            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2947            * @throws SystemException if a system exception occurred
2948            */
2949            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
2950                    long id, long groupId, long classNameId, java.lang.String templateId,
2951                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2952                    throws com.liferay.portal.kernel.exception.SystemException,
2953                            com.liferay.portlet.journal.NoSuchArticleException {
2954                    return getPersistence()
2955                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
2956                            templateId, orderByComparator);
2957            }
2958    
2959            /**
2960            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2961            *
2962            * @param groupId the group ID
2963            * @param classNameId the class name ID
2964            * @param templateId the template ID
2965            * @return the matching journal articles that the user has permission to view
2966            * @throws SystemException if a system exception occurred
2967            */
2968            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
2969                    long groupId, long classNameId, java.lang.String templateId)
2970                    throws com.liferay.portal.kernel.exception.SystemException {
2971                    return getPersistence()
2972                                       .filterFindByG_C_T(groupId, classNameId, templateId);
2973            }
2974    
2975            /**
2976            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
2977            *
2978            * <p>
2979            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2980            * </p>
2981            *
2982            * @param groupId the group ID
2983            * @param classNameId the class name ID
2984            * @param templateId the template ID
2985            * @param start the lower bound of the range of journal articles
2986            * @param end the upper bound of the range of journal articles (not inclusive)
2987            * @return the range of matching journal articles that the user has permission to view
2988            * @throws SystemException if a system exception occurred
2989            */
2990            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
2991                    long groupId, long classNameId, java.lang.String templateId, int start,
2992                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2993                    return getPersistence()
2994                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
2995                            end);
2996            }
2997    
2998            /**
2999            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3000            *
3001            * <p>
3002            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3003            * </p>
3004            *
3005            * @param groupId the group ID
3006            * @param classNameId the class name ID
3007            * @param templateId the template ID
3008            * @param start the lower bound of the range of journal articles
3009            * @param end the upper bound of the range of journal articles (not inclusive)
3010            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3011            * @return the ordered range of matching journal articles that the user has permission to view
3012            * @throws SystemException if a system exception occurred
3013            */
3014            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3015                    long groupId, long classNameId, java.lang.String templateId, int start,
3016                    int end,
3017                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3018                    throws com.liferay.portal.kernel.exception.SystemException {
3019                    return getPersistence()
3020                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3021                            end, orderByComparator);
3022            }
3023    
3024            /**
3025            * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3026            *
3027            * @param id the primary key of the current journal article
3028            * @param groupId the group ID
3029            * @param classNameId the class name ID
3030            * @param templateId the template ID
3031            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3032            * @return the previous, current, and next journal article
3033            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3034            * @throws SystemException if a system exception occurred
3035            */
3036            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
3037                    long id, long groupId, long classNameId, java.lang.String templateId,
3038                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3039                    throws com.liferay.portal.kernel.exception.SystemException,
3040                            com.liferay.portlet.journal.NoSuchArticleException {
3041                    return getPersistence()
3042                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
3043                            templateId, orderByComparator);
3044            }
3045    
3046            /**
3047            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3048            *
3049            * @param groupId the group ID
3050            * @param classNameId the class name ID
3051            * @param layoutUuid the layout uuid
3052            * @return the matching journal articles
3053            * @throws SystemException if a system exception occurred
3054            */
3055            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3056                    long groupId, long classNameId, java.lang.String layoutUuid)
3057                    throws com.liferay.portal.kernel.exception.SystemException {
3058                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
3059            }
3060    
3061            /**
3062            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3063            *
3064            * <p>
3065            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3066            * </p>
3067            *
3068            * @param groupId the group ID
3069            * @param classNameId the class name ID
3070            * @param layoutUuid the layout uuid
3071            * @param start the lower bound of the range of journal articles
3072            * @param end the upper bound of the range of journal articles (not inclusive)
3073            * @return the range of matching journal articles
3074            * @throws SystemException if a system exception occurred
3075            */
3076            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3077                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3078                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3079                    return getPersistence()
3080                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
3081            }
3082    
3083            /**
3084            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3085            *
3086            * <p>
3087            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3088            * </p>
3089            *
3090            * @param groupId the group ID
3091            * @param classNameId the class name ID
3092            * @param layoutUuid the layout uuid
3093            * @param start the lower bound of the range of journal articles
3094            * @param end the upper bound of the range of journal articles (not inclusive)
3095            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3096            * @return the ordered range of matching journal articles
3097            * @throws SystemException if a system exception occurred
3098            */
3099            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3100                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3101                    int end,
3102                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3103                    throws com.liferay.portal.kernel.exception.SystemException {
3104                    return getPersistence()
3105                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
3106                            orderByComparator);
3107            }
3108    
3109            /**
3110            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3111            *
3112            * <p>
3113            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3114            * </p>
3115            *
3116            * @param groupId the group ID
3117            * @param classNameId the class name ID
3118            * @param layoutUuid the layout uuid
3119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3120            * @return the first matching journal article
3121            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3122            * @throws SystemException if a system exception occurred
3123            */
3124            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
3125                    long groupId, long classNameId, java.lang.String layoutUuid,
3126                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3127                    throws com.liferay.portal.kernel.exception.SystemException,
3128                            com.liferay.portlet.journal.NoSuchArticleException {
3129                    return getPersistence()
3130                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
3131                            orderByComparator);
3132            }
3133    
3134            /**
3135            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3136            *
3137            * <p>
3138            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3139            * </p>
3140            *
3141            * @param groupId the group ID
3142            * @param classNameId the class name ID
3143            * @param layoutUuid the layout uuid
3144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3145            * @return the last matching journal article
3146            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3147            * @throws SystemException if a system exception occurred
3148            */
3149            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
3150                    long groupId, long classNameId, java.lang.String layoutUuid,
3151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3152                    throws com.liferay.portal.kernel.exception.SystemException,
3153                            com.liferay.portlet.journal.NoSuchArticleException {
3154                    return getPersistence()
3155                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
3156                            orderByComparator);
3157            }
3158    
3159            /**
3160            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3161            *
3162            * <p>
3163            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3164            * </p>
3165            *
3166            * @param id the primary key of the current journal article
3167            * @param groupId the group ID
3168            * @param classNameId the class name ID
3169            * @param layoutUuid the layout uuid
3170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3171            * @return the previous, current, and next journal article
3172            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3173            * @throws SystemException if a system exception occurred
3174            */
3175            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
3176                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3178                    throws com.liferay.portal.kernel.exception.SystemException,
3179                            com.liferay.portlet.journal.NoSuchArticleException {
3180                    return getPersistence()
3181                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
3182                            layoutUuid, orderByComparator);
3183            }
3184    
3185            /**
3186            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3187            *
3188            * @param groupId the group ID
3189            * @param classNameId the class name ID
3190            * @param layoutUuid the layout uuid
3191            * @return the matching journal articles that the user has permission to view
3192            * @throws SystemException if a system exception occurred
3193            */
3194            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3195                    long groupId, long classNameId, java.lang.String layoutUuid)
3196                    throws com.liferay.portal.kernel.exception.SystemException {
3197                    return getPersistence()
3198                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
3199            }
3200    
3201            /**
3202            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3203            *
3204            * <p>
3205            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3206            * </p>
3207            *
3208            * @param groupId the group ID
3209            * @param classNameId the class name ID
3210            * @param layoutUuid the layout uuid
3211            * @param start the lower bound of the range of journal articles
3212            * @param end the upper bound of the range of journal articles (not inclusive)
3213            * @return the range of matching journal articles that the user has permission to view
3214            * @throws SystemException if a system exception occurred
3215            */
3216            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3217                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3218                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3219                    return getPersistence()
3220                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3221                            end);
3222            }
3223    
3224            /**
3225            * 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;.
3226            *
3227            * <p>
3228            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3229            * </p>
3230            *
3231            * @param groupId the group ID
3232            * @param classNameId the class name ID
3233            * @param layoutUuid the layout uuid
3234            * @param start the lower bound of the range of journal articles
3235            * @param end the upper bound of the range of journal articles (not inclusive)
3236            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3237            * @return the ordered range of matching journal articles that the user has permission to view
3238            * @throws SystemException if a system exception occurred
3239            */
3240            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3241                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3242                    int end,
3243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3244                    throws com.liferay.portal.kernel.exception.SystemException {
3245                    return getPersistence()
3246                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3247                            end, orderByComparator);
3248            }
3249    
3250            /**
3251            * 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;.
3252            *
3253            * @param id the primary key of the current journal article
3254            * @param groupId the group ID
3255            * @param classNameId the class name ID
3256            * @param layoutUuid the layout uuid
3257            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3258            * @return the previous, current, and next journal article
3259            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3260            * @throws SystemException if a system exception occurred
3261            */
3262            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
3263                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3265                    throws com.liferay.portal.kernel.exception.SystemException,
3266                            com.liferay.portlet.journal.NoSuchArticleException {
3267                    return getPersistence()
3268                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
3269                            layoutUuid, orderByComparator);
3270            }
3271    
3272            /**
3273            * Returns the journal article where groupId = &#63; and articleId = &#63; and version = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found.
3274            *
3275            * @param groupId the group ID
3276            * @param articleId the article ID
3277            * @param version the version
3278            * @return the matching journal article
3279            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3280            * @throws SystemException if a system exception occurred
3281            */
3282            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
3283                    long groupId, java.lang.String articleId, double version)
3284                    throws com.liferay.portal.kernel.exception.SystemException,
3285                            com.liferay.portlet.journal.NoSuchArticleException {
3286                    return getPersistence().findByG_A_V(groupId, articleId, version);
3287            }
3288    
3289            /**
3290            * 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.
3291            *
3292            * @param groupId the group ID
3293            * @param articleId the article ID
3294            * @param version the version
3295            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3296            * @throws SystemException if a system exception occurred
3297            */
3298            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3299                    long groupId, java.lang.String articleId, double version)
3300                    throws com.liferay.portal.kernel.exception.SystemException {
3301                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
3302            }
3303    
3304            /**
3305            * 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.
3306            *
3307            * @param groupId the group ID
3308            * @param articleId the article ID
3309            * @param version the version
3310            * @param retrieveFromCache whether to use the finder cache
3311            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3312            * @throws SystemException if a system exception occurred
3313            */
3314            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3315                    long groupId, java.lang.String articleId, double version,
3316                    boolean retrieveFromCache)
3317                    throws com.liferay.portal.kernel.exception.SystemException {
3318                    return getPersistence()
3319                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
3320            }
3321    
3322            /**
3323            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3324            *
3325            * @param groupId the group ID
3326            * @param articleId the article ID
3327            * @param status the status
3328            * @return the matching journal articles
3329            * @throws SystemException if a system exception occurred
3330            */
3331            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3332                    long groupId, java.lang.String articleId, int status)
3333                    throws com.liferay.portal.kernel.exception.SystemException {
3334                    return getPersistence().findByG_A_ST(groupId, articleId, status);
3335            }
3336    
3337            /**
3338            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3339            *
3340            * <p>
3341            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3342            * </p>
3343            *
3344            * @param groupId the group ID
3345            * @param articleId the article ID
3346            * @param status the status
3347            * @param start the lower bound of the range of journal articles
3348            * @param end the upper bound of the range of journal articles (not inclusive)
3349            * @return the range of matching journal articles
3350            * @throws SystemException if a system exception occurred
3351            */
3352            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3353                    long groupId, java.lang.String articleId, int status, int start, int end)
3354                    throws com.liferay.portal.kernel.exception.SystemException {
3355                    return getPersistence()
3356                                       .findByG_A_ST(groupId, articleId, status, start, end);
3357            }
3358    
3359            /**
3360            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3361            *
3362            * <p>
3363            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3364            * </p>
3365            *
3366            * @param groupId the group ID
3367            * @param articleId the article ID
3368            * @param status the status
3369            * @param start the lower bound of the range of journal articles
3370            * @param end the upper bound of the range of journal articles (not inclusive)
3371            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3372            * @return the ordered range of matching journal articles
3373            * @throws SystemException if a system exception occurred
3374            */
3375            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3376                    long groupId, java.lang.String articleId, int status, int start,
3377                    int end,
3378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3379                    throws com.liferay.portal.kernel.exception.SystemException {
3380                    return getPersistence()
3381                                       .findByG_A_ST(groupId, articleId, status, start, end,
3382                            orderByComparator);
3383            }
3384    
3385            /**
3386            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3387            *
3388            * <p>
3389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3390            * </p>
3391            *
3392            * @param groupId the group ID
3393            * @param articleId the article ID
3394            * @param status the status
3395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3396            * @return the first matching journal article
3397            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3398            * @throws SystemException if a system exception occurred
3399            */
3400            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
3401                    long groupId, java.lang.String articleId, int status,
3402                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3403                    throws com.liferay.portal.kernel.exception.SystemException,
3404                            com.liferay.portlet.journal.NoSuchArticleException {
3405                    return getPersistence()
3406                                       .findByG_A_ST_First(groupId, articleId, status,
3407                            orderByComparator);
3408            }
3409    
3410            /**
3411            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3412            *
3413            * <p>
3414            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3415            * </p>
3416            *
3417            * @param groupId the group ID
3418            * @param articleId the article ID
3419            * @param status the status
3420            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3421            * @return the last matching journal article
3422            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3423            * @throws SystemException if a system exception occurred
3424            */
3425            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
3426                    long groupId, java.lang.String articleId, int status,
3427                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3428                    throws com.liferay.portal.kernel.exception.SystemException,
3429                            com.liferay.portlet.journal.NoSuchArticleException {
3430                    return getPersistence()
3431                                       .findByG_A_ST_Last(groupId, articleId, status,
3432                            orderByComparator);
3433            }
3434    
3435            /**
3436            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3437            *
3438            * <p>
3439            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3440            * </p>
3441            *
3442            * @param id the primary key of the current journal article
3443            * @param groupId the group ID
3444            * @param articleId the article ID
3445            * @param status the status
3446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3447            * @return the previous, current, and next journal article
3448            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3449            * @throws SystemException if a system exception occurred
3450            */
3451            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
3452                    long id, long groupId, java.lang.String articleId, int status,
3453                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3454                    throws com.liferay.portal.kernel.exception.SystemException,
3455                            com.liferay.portlet.journal.NoSuchArticleException {
3456                    return getPersistence()
3457                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
3458                            orderByComparator);
3459            }
3460    
3461            /**
3462            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
3463            *
3464            * <p>
3465            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3466            * </p>
3467            *
3468            * @param groupId the group ID
3469            * @param articleId the article ID
3470            * @param statuses the statuses
3471            * @return the matching journal articles
3472            * @throws SystemException if a system exception occurred
3473            */
3474            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3475                    long groupId, java.lang.String articleId, int[] statuses)
3476                    throws com.liferay.portal.kernel.exception.SystemException {
3477                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
3478            }
3479    
3480            /**
3481            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
3482            *
3483            * <p>
3484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3485            * </p>
3486            *
3487            * @param groupId the group ID
3488            * @param articleId the article ID
3489            * @param statuses the statuses
3490            * @param start the lower bound of the range of journal articles
3491            * @param end the upper bound of the range of journal articles (not inclusive)
3492            * @return the range of matching journal articles
3493            * @throws SystemException if a system exception occurred
3494            */
3495            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3496                    long groupId, java.lang.String articleId, int[] statuses, int start,
3497                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3498                    return getPersistence()
3499                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
3500            }
3501    
3502            /**
3503            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
3504            *
3505            * <p>
3506            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3507            * </p>
3508            *
3509            * @param groupId the group ID
3510            * @param articleId the article ID
3511            * @param statuses the statuses
3512            * @param start the lower bound of the range of journal articles
3513            * @param end the upper bound of the range of journal articles (not inclusive)
3514            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3515            * @return the ordered range of matching journal articles
3516            * @throws SystemException if a system exception occurred
3517            */
3518            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3519                    long groupId, java.lang.String articleId, int[] statuses, int start,
3520                    int end,
3521                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3522                    throws com.liferay.portal.kernel.exception.SystemException {
3523                    return getPersistence()
3524                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
3525                            orderByComparator);
3526            }
3527    
3528            /**
3529            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3530            *
3531            * @param groupId the group ID
3532            * @param articleId the article ID
3533            * @param status the status
3534            * @return the matching journal articles that the user has permission to view
3535            * @throws SystemException if a system exception occurred
3536            */
3537            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3538                    long groupId, java.lang.String articleId, int status)
3539                    throws com.liferay.portal.kernel.exception.SystemException {
3540                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
3541            }
3542    
3543            /**
3544            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3545            *
3546            * <p>
3547            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3548            * </p>
3549            *
3550            * @param groupId the group ID
3551            * @param articleId the article ID
3552            * @param status the status
3553            * @param start the lower bound of the range of journal articles
3554            * @param end the upper bound of the range of journal articles (not inclusive)
3555            * @return the range of matching journal articles that the user has permission to view
3556            * @throws SystemException if a system exception occurred
3557            */
3558            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3559                    long groupId, java.lang.String articleId, int status, int start, int end)
3560                    throws com.liferay.portal.kernel.exception.SystemException {
3561                    return getPersistence()
3562                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
3563            }
3564    
3565            /**
3566            * 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;.
3567            *
3568            * <p>
3569            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3570            * </p>
3571            *
3572            * @param groupId the group ID
3573            * @param articleId the article ID
3574            * @param status the status
3575            * @param start the lower bound of the range of journal articles
3576            * @param end the upper bound of the range of journal articles (not inclusive)
3577            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3578            * @return the ordered range of matching journal articles that the user has permission to view
3579            * @throws SystemException if a system exception occurred
3580            */
3581            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3582                    long groupId, java.lang.String articleId, int status, int start,
3583                    int end,
3584                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3585                    throws com.liferay.portal.kernel.exception.SystemException {
3586                    return getPersistence()
3587                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
3588                            orderByComparator);
3589            }
3590    
3591            /**
3592            * 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;.
3593            *
3594            * @param id the primary key of the current journal article
3595            * @param groupId the group ID
3596            * @param articleId the article ID
3597            * @param status the status
3598            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3599            * @return the previous, current, and next journal article
3600            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3601            * @throws SystemException if a system exception occurred
3602            */
3603            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
3604                    long id, long groupId, java.lang.String articleId, int status,
3605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3606                    throws com.liferay.portal.kernel.exception.SystemException,
3607                            com.liferay.portlet.journal.NoSuchArticleException {
3608                    return getPersistence()
3609                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
3610                            status, orderByComparator);
3611            }
3612    
3613            /**
3614            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
3615            *
3616            * @param groupId the group ID
3617            * @param articleId the article ID
3618            * @param statuses the statuses
3619            * @return the matching journal articles that the user has permission to view
3620            * @throws SystemException if a system exception occurred
3621            */
3622            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3623                    long groupId, java.lang.String articleId, int[] statuses)
3624                    throws com.liferay.portal.kernel.exception.SystemException {
3625                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
3626            }
3627    
3628            /**
3629            * 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;.
3630            *
3631            * <p>
3632            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3633            * </p>
3634            *
3635            * @param groupId the group ID
3636            * @param articleId the article ID
3637            * @param statuses the statuses
3638            * @param start the lower bound of the range of journal articles
3639            * @param end the upper bound of the range of journal articles (not inclusive)
3640            * @return the range of matching journal articles that the user has permission to view
3641            * @throws SystemException if a system exception occurred
3642            */
3643            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3644                    long groupId, java.lang.String articleId, int[] statuses, int start,
3645                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3646                    return getPersistence()
3647                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
3648            }
3649    
3650            /**
3651            * 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;.
3652            *
3653            * <p>
3654            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3655            * </p>
3656            *
3657            * @param groupId the group ID
3658            * @param articleId the article ID
3659            * @param statuses the statuses
3660            * @param start the lower bound of the range of journal articles
3661            * @param end the upper bound of the range of journal articles (not inclusive)
3662            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3663            * @return the ordered range of matching journal articles that the user has permission to view
3664            * @throws SystemException if a system exception occurred
3665            */
3666            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3667                    long groupId, java.lang.String articleId, int[] statuses, int start,
3668                    int end,
3669                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3670                    throws com.liferay.portal.kernel.exception.SystemException {
3671                    return getPersistence()
3672                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
3673                            end, orderByComparator);
3674            }
3675    
3676            /**
3677            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3678            *
3679            * @param groupId the group ID
3680            * @param urlTitle the url title
3681            * @param status the status
3682            * @return the matching journal articles
3683            * @throws SystemException if a system exception occurred
3684            */
3685            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3686                    long groupId, java.lang.String urlTitle, int status)
3687                    throws com.liferay.portal.kernel.exception.SystemException {
3688                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
3689            }
3690    
3691            /**
3692            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3693            *
3694            * <p>
3695            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3696            * </p>
3697            *
3698            * @param groupId the group ID
3699            * @param urlTitle the url title
3700            * @param status the status
3701            * @param start the lower bound of the range of journal articles
3702            * @param end the upper bound of the range of journal articles (not inclusive)
3703            * @return the range of matching journal articles
3704            * @throws SystemException if a system exception occurred
3705            */
3706            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3707                    long groupId, java.lang.String urlTitle, int status, int start, int end)
3708                    throws com.liferay.portal.kernel.exception.SystemException {
3709                    return getPersistence()
3710                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
3711            }
3712    
3713            /**
3714            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3715            *
3716            * <p>
3717            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3718            * </p>
3719            *
3720            * @param groupId the group ID
3721            * @param urlTitle the url title
3722            * @param status the status
3723            * @param start the lower bound of the range of journal articles
3724            * @param end the upper bound of the range of journal articles (not inclusive)
3725            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3726            * @return the ordered range of matching journal articles
3727            * @throws SystemException if a system exception occurred
3728            */
3729            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3730                    long groupId, java.lang.String urlTitle, int status, int start,
3731                    int end,
3732                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3733                    throws com.liferay.portal.kernel.exception.SystemException {
3734                    return getPersistence()
3735                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
3736                            orderByComparator);
3737            }
3738    
3739            /**
3740            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3741            *
3742            * <p>
3743            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3744            * </p>
3745            *
3746            * @param groupId the group ID
3747            * @param urlTitle the url title
3748            * @param status the status
3749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3750            * @return the first matching journal article
3751            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3752            * @throws SystemException if a system exception occurred
3753            */
3754            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
3755                    long groupId, java.lang.String urlTitle, int status,
3756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3757                    throws com.liferay.portal.kernel.exception.SystemException,
3758                            com.liferay.portlet.journal.NoSuchArticleException {
3759                    return getPersistence()
3760                                       .findByG_UT_ST_First(groupId, urlTitle, status,
3761                            orderByComparator);
3762            }
3763    
3764            /**
3765            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3766            *
3767            * <p>
3768            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3769            * </p>
3770            *
3771            * @param groupId the group ID
3772            * @param urlTitle the url title
3773            * @param status the status
3774            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3775            * @return the last matching journal article
3776            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3777            * @throws SystemException if a system exception occurred
3778            */
3779            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
3780                    long groupId, java.lang.String urlTitle, int status,
3781                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3782                    throws com.liferay.portal.kernel.exception.SystemException,
3783                            com.liferay.portlet.journal.NoSuchArticleException {
3784                    return getPersistence()
3785                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
3786                            orderByComparator);
3787            }
3788    
3789            /**
3790            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3791            *
3792            * <p>
3793            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3794            * </p>
3795            *
3796            * @param id the primary key of the current journal article
3797            * @param groupId the group ID
3798            * @param urlTitle the url title
3799            * @param status the status
3800            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3801            * @return the previous, current, and next journal article
3802            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3803            * @throws SystemException if a system exception occurred
3804            */
3805            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
3806                    long id, long groupId, java.lang.String urlTitle, int status,
3807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3808                    throws com.liferay.portal.kernel.exception.SystemException,
3809                            com.liferay.portlet.journal.NoSuchArticleException {
3810                    return getPersistence()
3811                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
3812                            orderByComparator);
3813            }
3814    
3815            /**
3816            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3817            *
3818            * @param groupId the group ID
3819            * @param urlTitle the url title
3820            * @param status the status
3821            * @return the matching journal articles that the user has permission to view
3822            * @throws SystemException if a system exception occurred
3823            */
3824            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
3825                    long groupId, java.lang.String urlTitle, int status)
3826                    throws com.liferay.portal.kernel.exception.SystemException {
3827                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
3828            }
3829    
3830            /**
3831            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3832            *
3833            * <p>
3834            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3835            * </p>
3836            *
3837            * @param groupId the group ID
3838            * @param urlTitle the url title
3839            * @param status the status
3840            * @param start the lower bound of the range of journal articles
3841            * @param end the upper bound of the range of journal articles (not inclusive)
3842            * @return the range of matching journal articles that the user has permission to view
3843            * @throws SystemException if a system exception occurred
3844            */
3845            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
3846                    long groupId, java.lang.String urlTitle, int status, int start, int end)
3847                    throws com.liferay.portal.kernel.exception.SystemException {
3848                    return getPersistence()
3849                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
3850            }
3851    
3852            /**
3853            * 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;.
3854            *
3855            * <p>
3856            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3857            * </p>
3858            *
3859            * @param groupId the group ID
3860            * @param urlTitle the url title
3861            * @param status the status
3862            * @param start the lower bound of the range of journal articles
3863            * @param end the upper bound of the range of journal articles (not inclusive)
3864            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3865            * @return the ordered range of matching journal articles that the user has permission to view
3866            * @throws SystemException if a system exception occurred
3867            */
3868            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
3869                    long groupId, java.lang.String urlTitle, int status, int start,
3870                    int end,
3871                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3872                    throws com.liferay.portal.kernel.exception.SystemException {
3873                    return getPersistence()
3874                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
3875                            orderByComparator);
3876            }
3877    
3878            /**
3879            * 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;.
3880            *
3881            * @param id the primary key of the current journal article
3882            * @param groupId the group ID
3883            * @param urlTitle the url title
3884            * @param status the status
3885            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3886            * @return the previous, current, and next journal article
3887            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3888            * @throws SystemException if a system exception occurred
3889            */
3890            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
3891                    long id, long groupId, java.lang.String urlTitle, int status,
3892                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3893                    throws com.liferay.portal.kernel.exception.SystemException,
3894                            com.liferay.portlet.journal.NoSuchArticleException {
3895                    return getPersistence()
3896                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
3897                            status, orderByComparator);
3898            }
3899    
3900            /**
3901            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
3902            *
3903            * @param companyId the company ID
3904            * @param version the version
3905            * @param status the status
3906            * @return the matching journal articles
3907            * @throws SystemException if a system exception occurred
3908            */
3909            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
3910                    long companyId, double version, int status)
3911                    throws com.liferay.portal.kernel.exception.SystemException {
3912                    return getPersistence().findByC_V_ST(companyId, version, status);
3913            }
3914    
3915            /**
3916            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
3917            *
3918            * <p>
3919            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3920            * </p>
3921            *
3922            * @param companyId the company ID
3923            * @param version the version
3924            * @param status the status
3925            * @param start the lower bound of the range of journal articles
3926            * @param end the upper bound of the range of journal articles (not inclusive)
3927            * @return the range of matching journal articles
3928            * @throws SystemException if a system exception occurred
3929            */
3930            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
3931                    long companyId, double version, int status, int start, int end)
3932                    throws com.liferay.portal.kernel.exception.SystemException {
3933                    return getPersistence()
3934                                       .findByC_V_ST(companyId, version, status, start, end);
3935            }
3936    
3937            /**
3938            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
3939            *
3940            * <p>
3941            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3942            * </p>
3943            *
3944            * @param companyId the company ID
3945            * @param version the version
3946            * @param status the status
3947            * @param start the lower bound of the range of journal articles
3948            * @param end the upper bound of the range of journal articles (not inclusive)
3949            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3950            * @return the ordered range of matching journal articles
3951            * @throws SystemException if a system exception occurred
3952            */
3953            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
3954                    long companyId, double version, int status, int start, int end,
3955                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3956                    throws com.liferay.portal.kernel.exception.SystemException {
3957                    return getPersistence()
3958                                       .findByC_V_ST(companyId, version, status, start, end,
3959                            orderByComparator);
3960            }
3961    
3962            /**
3963            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
3964            *
3965            * <p>
3966            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3967            * </p>
3968            *
3969            * @param companyId the company ID
3970            * @param version the version
3971            * @param status the status
3972            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3973            * @return the first matching journal article
3974            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3975            * @throws SystemException if a system exception occurred
3976            */
3977            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
3978                    long companyId, double version, int status,
3979                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3980                    throws com.liferay.portal.kernel.exception.SystemException,
3981                            com.liferay.portlet.journal.NoSuchArticleException {
3982                    return getPersistence()
3983                                       .findByC_V_ST_First(companyId, version, status,
3984                            orderByComparator);
3985            }
3986    
3987            /**
3988            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
3989            *
3990            * <p>
3991            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3992            * </p>
3993            *
3994            * @param companyId the company ID
3995            * @param version the version
3996            * @param status the status
3997            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3998            * @return the last matching journal article
3999            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4000            * @throws SystemException if a system exception occurred
4001            */
4002            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
4003                    long companyId, double version, int status,
4004                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4005                    throws com.liferay.portal.kernel.exception.SystemException,
4006                            com.liferay.portlet.journal.NoSuchArticleException {
4007                    return getPersistence()
4008                                       .findByC_V_ST_Last(companyId, version, status,
4009                            orderByComparator);
4010            }
4011    
4012            /**
4013            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4014            *
4015            * <p>
4016            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4017            * </p>
4018            *
4019            * @param id the primary key of the current journal article
4020            * @param companyId the company ID
4021            * @param version the version
4022            * @param status the status
4023            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4024            * @return the previous, current, and next journal article
4025            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4026            * @throws SystemException if a system exception occurred
4027            */
4028            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
4029                    long id, long companyId, double version, int status,
4030                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4031                    throws com.liferay.portal.kernel.exception.SystemException,
4032                            com.liferay.portlet.journal.NoSuchArticleException {
4033                    return getPersistence()
4034                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
4035                            orderByComparator);
4036            }
4037    
4038            /**
4039            * Returns all the journal articles.
4040            *
4041            * @return the journal articles
4042            * @throws SystemException if a system exception occurred
4043            */
4044            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
4045                    throws com.liferay.portal.kernel.exception.SystemException {
4046                    return getPersistence().findAll();
4047            }
4048    
4049            /**
4050            * Returns a range of all the journal articles.
4051            *
4052            * <p>
4053            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4054            * </p>
4055            *
4056            * @param start the lower bound of the range of journal articles
4057            * @param end the upper bound of the range of journal articles (not inclusive)
4058            * @return the range of journal articles
4059            * @throws SystemException if a system exception occurred
4060            */
4061            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
4062                    int start, int end)
4063                    throws com.liferay.portal.kernel.exception.SystemException {
4064                    return getPersistence().findAll(start, end);
4065            }
4066    
4067            /**
4068            * Returns an ordered range of all the journal articles.
4069            *
4070            * <p>
4071            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4072            * </p>
4073            *
4074            * @param start the lower bound of the range of journal articles
4075            * @param end the upper bound of the range of journal articles (not inclusive)
4076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4077            * @return the ordered range of journal articles
4078            * @throws SystemException if a system exception occurred
4079            */
4080            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
4081                    int start, int end,
4082                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4083                    throws com.liferay.portal.kernel.exception.SystemException {
4084                    return getPersistence().findAll(start, end, orderByComparator);
4085            }
4086    
4087            /**
4088            * Removes all the journal articles where uuid = &#63; from the database.
4089            *
4090            * @param uuid the uuid
4091            * @throws SystemException if a system exception occurred
4092            */
4093            public static void removeByUuid(java.lang.String uuid)
4094                    throws com.liferay.portal.kernel.exception.SystemException {
4095                    getPersistence().removeByUuid(uuid);
4096            }
4097    
4098            /**
4099            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
4100            *
4101            * @param uuid the uuid
4102            * @param groupId the group ID
4103            * @throws SystemException if a system exception occurred
4104            */
4105            public static void removeByUUID_G(java.lang.String uuid, long groupId)
4106                    throws com.liferay.portal.kernel.exception.SystemException,
4107                            com.liferay.portlet.journal.NoSuchArticleException {
4108                    getPersistence().removeByUUID_G(uuid, groupId);
4109            }
4110    
4111            /**
4112            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
4113            *
4114            * @param resourcePrimKey the resource prim key
4115            * @throws SystemException if a system exception occurred
4116            */
4117            public static void removeByResourcePrimKey(long resourcePrimKey)
4118                    throws com.liferay.portal.kernel.exception.SystemException {
4119                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
4120            }
4121    
4122            /**
4123            * Removes all the journal articles where groupId = &#63; from the database.
4124            *
4125            * @param groupId the group ID
4126            * @throws SystemException if a system exception occurred
4127            */
4128            public static void removeByGroupId(long groupId)
4129                    throws com.liferay.portal.kernel.exception.SystemException {
4130                    getPersistence().removeByGroupId(groupId);
4131            }
4132    
4133            /**
4134            * Removes all the journal articles where companyId = &#63; from the database.
4135            *
4136            * @param companyId the company ID
4137            * @throws SystemException if a system exception occurred
4138            */
4139            public static void removeByCompanyId(long companyId)
4140                    throws com.liferay.portal.kernel.exception.SystemException {
4141                    getPersistence().removeByCompanyId(companyId);
4142            }
4143    
4144            /**
4145            * Removes all the journal articles where smallImageId = &#63; from the database.
4146            *
4147            * @param smallImageId the small image ID
4148            * @throws SystemException if a system exception occurred
4149            */
4150            public static void removeBySmallImageId(long smallImageId)
4151                    throws com.liferay.portal.kernel.exception.SystemException {
4152                    getPersistence().removeBySmallImageId(smallImageId);
4153            }
4154    
4155            /**
4156            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
4157            *
4158            * @param resourcePrimKey the resource prim key
4159            * @param status the status
4160            * @throws SystemException if a system exception occurred
4161            */
4162            public static void removeByR_ST(long resourcePrimKey, int status)
4163                    throws com.liferay.portal.kernel.exception.SystemException {
4164                    getPersistence().removeByR_ST(resourcePrimKey, status);
4165            }
4166    
4167            /**
4168            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
4169            *
4170            * @param groupId the group ID
4171            * @param articleId the article ID
4172            * @throws SystemException if a system exception occurred
4173            */
4174            public static void removeByG_A(long groupId, java.lang.String articleId)
4175                    throws com.liferay.portal.kernel.exception.SystemException {
4176                    getPersistence().removeByG_A(groupId, articleId);
4177            }
4178    
4179            /**
4180            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
4181            *
4182            * @param groupId the group ID
4183            * @param urlTitle the url title
4184            * @throws SystemException if a system exception occurred
4185            */
4186            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
4187                    throws com.liferay.portal.kernel.exception.SystemException {
4188                    getPersistence().removeByG_UT(groupId, urlTitle);
4189            }
4190    
4191            /**
4192            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
4193            *
4194            * @param groupId the group ID
4195            * @param structureId the structure ID
4196            * @throws SystemException if a system exception occurred
4197            */
4198            public static void removeByG_S(long groupId, java.lang.String structureId)
4199                    throws com.liferay.portal.kernel.exception.SystemException {
4200                    getPersistence().removeByG_S(groupId, structureId);
4201            }
4202    
4203            /**
4204            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
4205            *
4206            * @param groupId the group ID
4207            * @param templateId the template ID
4208            * @throws SystemException if a system exception occurred
4209            */
4210            public static void removeByG_T(long groupId, java.lang.String templateId)
4211                    throws com.liferay.portal.kernel.exception.SystemException {
4212                    getPersistence().removeByG_T(groupId, templateId);
4213            }
4214    
4215            /**
4216            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
4217            *
4218            * @param groupId the group ID
4219            * @param layoutUuid the layout uuid
4220            * @throws SystemException if a system exception occurred
4221            */
4222            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
4223                    throws com.liferay.portal.kernel.exception.SystemException {
4224                    getPersistence().removeByG_L(groupId, layoutUuid);
4225            }
4226    
4227            /**
4228            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4229            *
4230            * @param groupId the group ID
4231            * @param status the status
4232            * @throws SystemException if a system exception occurred
4233            */
4234            public static void removeByG_ST(long groupId, int status)
4235                    throws com.liferay.portal.kernel.exception.SystemException {
4236                    getPersistence().removeByG_ST(groupId, status);
4237            }
4238    
4239            /**
4240            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4241            *
4242            * @param companyId the company ID
4243            * @param version the version
4244            * @throws SystemException if a system exception occurred
4245            */
4246            public static void removeByC_V(long companyId, double version)
4247                    throws com.liferay.portal.kernel.exception.SystemException {
4248                    getPersistence().removeByC_V(companyId, version);
4249            }
4250    
4251            /**
4252            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4253            *
4254            * @param companyId the company ID
4255            * @param status the status
4256            * @throws SystemException if a system exception occurred
4257            */
4258            public static void removeByC_ST(long companyId, int status)
4259                    throws com.liferay.portal.kernel.exception.SystemException {
4260                    getPersistence().removeByC_ST(companyId, status);
4261            }
4262    
4263            /**
4264            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
4265            *
4266            * @param groupId the group ID
4267            * @param classNameId the class name ID
4268            * @param classPK the class p k
4269            * @throws SystemException if a system exception occurred
4270            */
4271            public static void removeByG_C_C(long groupId, long classNameId,
4272                    long classPK)
4273                    throws com.liferay.portal.kernel.exception.SystemException {
4274                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
4275            }
4276    
4277            /**
4278            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
4279            *
4280            * @param groupId the group ID
4281            * @param classNameId the class name ID
4282            * @param structureId the structure ID
4283            * @throws SystemException if a system exception occurred
4284            */
4285            public static void removeByG_C_S(long groupId, long classNameId,
4286                    java.lang.String structureId)
4287                    throws com.liferay.portal.kernel.exception.SystemException,
4288                            com.liferay.portlet.journal.NoSuchArticleException {
4289                    getPersistence().removeByG_C_S(groupId, classNameId, structureId);
4290            }
4291    
4292            /**
4293            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
4294            *
4295            * @param groupId the group ID
4296            * @param classNameId the class name ID
4297            * @param templateId the template ID
4298            * @throws SystemException if a system exception occurred
4299            */
4300            public static void removeByG_C_T(long groupId, long classNameId,
4301                    java.lang.String templateId)
4302                    throws com.liferay.portal.kernel.exception.SystemException {
4303                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
4304            }
4305    
4306            /**
4307            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
4308            *
4309            * @param groupId the group ID
4310            * @param classNameId the class name ID
4311            * @param layoutUuid the layout uuid
4312            * @throws SystemException if a system exception occurred
4313            */
4314            public static void removeByG_C_L(long groupId, long classNameId,
4315                    java.lang.String layoutUuid)
4316                    throws com.liferay.portal.kernel.exception.SystemException {
4317                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
4318            }
4319    
4320            /**
4321            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
4322            *
4323            * @param groupId the group ID
4324            * @param articleId the article ID
4325            * @param version the version
4326            * @throws SystemException if a system exception occurred
4327            */
4328            public static void removeByG_A_V(long groupId, java.lang.String articleId,
4329                    double version)
4330                    throws com.liferay.portal.kernel.exception.SystemException,
4331                            com.liferay.portlet.journal.NoSuchArticleException {
4332                    getPersistence().removeByG_A_V(groupId, articleId, version);
4333            }
4334    
4335            /**
4336            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
4337            *
4338            * @param groupId the group ID
4339            * @param articleId the article ID
4340            * @param status the status
4341            * @throws SystemException if a system exception occurred
4342            */
4343            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
4344                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4345                    getPersistence().removeByG_A_ST(groupId, articleId, status);
4346            }
4347    
4348            /**
4349            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
4350            *
4351            * @param groupId the group ID
4352            * @param urlTitle the url title
4353            * @param status the status
4354            * @throws SystemException if a system exception occurred
4355            */
4356            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
4357                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4358                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
4359            }
4360    
4361            /**
4362            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
4363            *
4364            * @param companyId the company ID
4365            * @param version the version
4366            * @param status the status
4367            * @throws SystemException if a system exception occurred
4368            */
4369            public static void removeByC_V_ST(long companyId, double version, int status)
4370                    throws com.liferay.portal.kernel.exception.SystemException {
4371                    getPersistence().removeByC_V_ST(companyId, version, status);
4372            }
4373    
4374            /**
4375            * Removes all the journal articles from the database.
4376            *
4377            * @throws SystemException if a system exception occurred
4378            */
4379            public static void removeAll()
4380                    throws com.liferay.portal.kernel.exception.SystemException {
4381                    getPersistence().removeAll();
4382            }
4383    
4384            /**
4385            * Returns the number of journal articles where uuid = &#63;.
4386            *
4387            * @param uuid the uuid
4388            * @return the number of matching journal articles
4389            * @throws SystemException if a system exception occurred
4390            */
4391            public static int countByUuid(java.lang.String uuid)
4392                    throws com.liferay.portal.kernel.exception.SystemException {
4393                    return getPersistence().countByUuid(uuid);
4394            }
4395    
4396            /**
4397            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
4398            *
4399            * @param uuid the uuid
4400            * @param groupId the group ID
4401            * @return the number of matching journal articles
4402            * @throws SystemException if a system exception occurred
4403            */
4404            public static int countByUUID_G(java.lang.String uuid, long groupId)
4405                    throws com.liferay.portal.kernel.exception.SystemException {
4406                    return getPersistence().countByUUID_G(uuid, groupId);
4407            }
4408    
4409            /**
4410            * Returns the number of journal articles where resourcePrimKey = &#63;.
4411            *
4412            * @param resourcePrimKey the resource prim key
4413            * @return the number of matching journal articles
4414            * @throws SystemException if a system exception occurred
4415            */
4416            public static int countByResourcePrimKey(long resourcePrimKey)
4417                    throws com.liferay.portal.kernel.exception.SystemException {
4418                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
4419            }
4420    
4421            /**
4422            * Returns the number of journal articles where groupId = &#63;.
4423            *
4424            * @param groupId the group ID
4425            * @return the number of matching journal articles
4426            * @throws SystemException if a system exception occurred
4427            */
4428            public static int countByGroupId(long groupId)
4429                    throws com.liferay.portal.kernel.exception.SystemException {
4430                    return getPersistence().countByGroupId(groupId);
4431            }
4432    
4433            /**
4434            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
4435            *
4436            * @param groupId the group ID
4437            * @return the number of matching journal articles that the user has permission to view
4438            * @throws SystemException if a system exception occurred
4439            */
4440            public static int filterCountByGroupId(long groupId)
4441                    throws com.liferay.portal.kernel.exception.SystemException {
4442                    return getPersistence().filterCountByGroupId(groupId);
4443            }
4444    
4445            /**
4446            * Returns the number of journal articles where companyId = &#63;.
4447            *
4448            * @param companyId the company ID
4449            * @return the number of matching journal articles
4450            * @throws SystemException if a system exception occurred
4451            */
4452            public static int countByCompanyId(long companyId)
4453                    throws com.liferay.portal.kernel.exception.SystemException {
4454                    return getPersistence().countByCompanyId(companyId);
4455            }
4456    
4457            /**
4458            * Returns the number of journal articles where smallImageId = &#63;.
4459            *
4460            * @param smallImageId the small image ID
4461            * @return the number of matching journal articles
4462            * @throws SystemException if a system exception occurred
4463            */
4464            public static int countBySmallImageId(long smallImageId)
4465                    throws com.liferay.portal.kernel.exception.SystemException {
4466                    return getPersistence().countBySmallImageId(smallImageId);
4467            }
4468    
4469            /**
4470            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
4471            *
4472            * @param resourcePrimKey the resource prim key
4473            * @param status the status
4474            * @return the number of matching journal articles
4475            * @throws SystemException if a system exception occurred
4476            */
4477            public static int countByR_ST(long resourcePrimKey, int status)
4478                    throws com.liferay.portal.kernel.exception.SystemException {
4479                    return getPersistence().countByR_ST(resourcePrimKey, status);
4480            }
4481    
4482            /**
4483            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
4484            *
4485            * @param groupId the group ID
4486            * @param articleId the article ID
4487            * @return the number of matching journal articles
4488            * @throws SystemException if a system exception occurred
4489            */
4490            public static int countByG_A(long groupId, java.lang.String articleId)
4491                    throws com.liferay.portal.kernel.exception.SystemException {
4492                    return getPersistence().countByG_A(groupId, articleId);
4493            }
4494    
4495            /**
4496            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
4497            *
4498            * @param groupId the group ID
4499            * @param articleId the article ID
4500            * @return the number of matching journal articles that the user has permission to view
4501            * @throws SystemException if a system exception occurred
4502            */
4503            public static int filterCountByG_A(long groupId, java.lang.String articleId)
4504                    throws com.liferay.portal.kernel.exception.SystemException {
4505                    return getPersistence().filterCountByG_A(groupId, articleId);
4506            }
4507    
4508            /**
4509            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
4510            *
4511            * @param groupId the group ID
4512            * @param urlTitle the url title
4513            * @return the number of matching journal articles
4514            * @throws SystemException if a system exception occurred
4515            */
4516            public static int countByG_UT(long groupId, java.lang.String urlTitle)
4517                    throws com.liferay.portal.kernel.exception.SystemException {
4518                    return getPersistence().countByG_UT(groupId, urlTitle);
4519            }
4520    
4521            /**
4522            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
4523            *
4524            * @param groupId the group ID
4525            * @param urlTitle the url title
4526            * @return the number of matching journal articles that the user has permission to view
4527            * @throws SystemException if a system exception occurred
4528            */
4529            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
4530                    throws com.liferay.portal.kernel.exception.SystemException {
4531                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
4532            }
4533    
4534            /**
4535            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
4536            *
4537            * @param groupId the group ID
4538            * @param structureId the structure ID
4539            * @return the number of matching journal articles
4540            * @throws SystemException if a system exception occurred
4541            */
4542            public static int countByG_S(long groupId, java.lang.String structureId)
4543                    throws com.liferay.portal.kernel.exception.SystemException {
4544                    return getPersistence().countByG_S(groupId, structureId);
4545            }
4546    
4547            /**
4548            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
4549            *
4550            * @param groupId the group ID
4551            * @param structureId the structure ID
4552            * @return the number of matching journal articles that the user has permission to view
4553            * @throws SystemException if a system exception occurred
4554            */
4555            public static int filterCountByG_S(long groupId,
4556                    java.lang.String structureId)
4557                    throws com.liferay.portal.kernel.exception.SystemException {
4558                    return getPersistence().filterCountByG_S(groupId, structureId);
4559            }
4560    
4561            /**
4562            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
4563            *
4564            * @param groupId the group ID
4565            * @param templateId the template ID
4566            * @return the number of matching journal articles
4567            * @throws SystemException if a system exception occurred
4568            */
4569            public static int countByG_T(long groupId, java.lang.String templateId)
4570                    throws com.liferay.portal.kernel.exception.SystemException {
4571                    return getPersistence().countByG_T(groupId, templateId);
4572            }
4573    
4574            /**
4575            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
4576            *
4577            * @param groupId the group ID
4578            * @param templateId the template ID
4579            * @return the number of matching journal articles that the user has permission to view
4580            * @throws SystemException if a system exception occurred
4581            */
4582            public static int filterCountByG_T(long groupId, java.lang.String templateId)
4583                    throws com.liferay.portal.kernel.exception.SystemException {
4584                    return getPersistence().filterCountByG_T(groupId, templateId);
4585            }
4586    
4587            /**
4588            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4589            *
4590            * @param groupId the group ID
4591            * @param layoutUuid the layout uuid
4592            * @return the number of matching journal articles
4593            * @throws SystemException if a system exception occurred
4594            */
4595            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4596                    throws com.liferay.portal.kernel.exception.SystemException {
4597                    return getPersistence().countByG_L(groupId, layoutUuid);
4598            }
4599    
4600            /**
4601            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4602            *
4603            * @param groupId the group ID
4604            * @param layoutUuid the layout uuid
4605            * @return the number of matching journal articles that the user has permission to view
4606            * @throws SystemException if a system exception occurred
4607            */
4608            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4609                    throws com.liferay.portal.kernel.exception.SystemException {
4610                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4611            }
4612    
4613            /**
4614            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4615            *
4616            * @param groupId the group ID
4617            * @param status the status
4618            * @return the number of matching journal articles
4619            * @throws SystemException if a system exception occurred
4620            */
4621            public static int countByG_ST(long groupId, int status)
4622                    throws com.liferay.portal.kernel.exception.SystemException {
4623                    return getPersistence().countByG_ST(groupId, status);
4624            }
4625    
4626            /**
4627            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4628            *
4629            * @param groupId the group ID
4630            * @param status the status
4631            * @return the number of matching journal articles that the user has permission to view
4632            * @throws SystemException if a system exception occurred
4633            */
4634            public static int filterCountByG_ST(long groupId, int status)
4635                    throws com.liferay.portal.kernel.exception.SystemException {
4636                    return getPersistence().filterCountByG_ST(groupId, status);
4637            }
4638    
4639            /**
4640            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4641            *
4642            * @param companyId the company ID
4643            * @param version the version
4644            * @return the number of matching journal articles
4645            * @throws SystemException if a system exception occurred
4646            */
4647            public static int countByC_V(long companyId, double version)
4648                    throws com.liferay.portal.kernel.exception.SystemException {
4649                    return getPersistence().countByC_V(companyId, version);
4650            }
4651    
4652            /**
4653            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4654            *
4655            * @param companyId the company ID
4656            * @param status the status
4657            * @return the number of matching journal articles
4658            * @throws SystemException if a system exception occurred
4659            */
4660            public static int countByC_ST(long companyId, int status)
4661                    throws com.liferay.portal.kernel.exception.SystemException {
4662                    return getPersistence().countByC_ST(companyId, status);
4663            }
4664    
4665            /**
4666            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4667            *
4668            * @param groupId the group ID
4669            * @param classNameId the class name ID
4670            * @param classPK the class p k
4671            * @return the number of matching journal articles
4672            * @throws SystemException if a system exception occurred
4673            */
4674            public static int countByG_C_C(long groupId, long classNameId, long classPK)
4675                    throws com.liferay.portal.kernel.exception.SystemException {
4676                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
4677            }
4678    
4679            /**
4680            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4681            *
4682            * @param groupId the group ID
4683            * @param classNameId the class name ID
4684            * @param classPK the class p k
4685            * @return the number of matching journal articles that the user has permission to view
4686            * @throws SystemException if a system exception occurred
4687            */
4688            public static int filterCountByG_C_C(long groupId, long classNameId,
4689                    long classPK)
4690                    throws com.liferay.portal.kernel.exception.SystemException {
4691                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
4692            }
4693    
4694            /**
4695            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
4696            *
4697            * @param groupId the group ID
4698            * @param classNameId the class name ID
4699            * @param structureId the structure ID
4700            * @return the number of matching journal articles
4701            * @throws SystemException if a system exception occurred
4702            */
4703            public static int countByG_C_S(long groupId, long classNameId,
4704                    java.lang.String structureId)
4705                    throws com.liferay.portal.kernel.exception.SystemException {
4706                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
4707            }
4708    
4709            /**
4710            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
4711            *
4712            * @param groupId the group ID
4713            * @param classNameId the class name ID
4714            * @param templateId the template ID
4715            * @return the number of matching journal articles
4716            * @throws SystemException if a system exception occurred
4717            */
4718            public static int countByG_C_T(long groupId, long classNameId,
4719                    java.lang.String templateId)
4720                    throws com.liferay.portal.kernel.exception.SystemException {
4721                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
4722            }
4723    
4724            /**
4725            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
4726            *
4727            * @param groupId the group ID
4728            * @param classNameId the class name ID
4729            * @param templateId the template ID
4730            * @return the number of matching journal articles that the user has permission to view
4731            * @throws SystemException if a system exception occurred
4732            */
4733            public static int filterCountByG_C_T(long groupId, long classNameId,
4734                    java.lang.String templateId)
4735                    throws com.liferay.portal.kernel.exception.SystemException {
4736                    return getPersistence()
4737                                       .filterCountByG_C_T(groupId, classNameId, templateId);
4738            }
4739    
4740            /**
4741            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
4742            *
4743            * @param groupId the group ID
4744            * @param classNameId the class name ID
4745            * @param layoutUuid the layout uuid
4746            * @return the number of matching journal articles
4747            * @throws SystemException if a system exception occurred
4748            */
4749            public static int countByG_C_L(long groupId, long classNameId,
4750                    java.lang.String layoutUuid)
4751                    throws com.liferay.portal.kernel.exception.SystemException {
4752                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
4753            }
4754    
4755            /**
4756            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
4757            *
4758            * @param groupId the group ID
4759            * @param classNameId the class name ID
4760            * @param layoutUuid the layout uuid
4761            * @return the number of matching journal articles that the user has permission to view
4762            * @throws SystemException if a system exception occurred
4763            */
4764            public static int filterCountByG_C_L(long groupId, long classNameId,
4765                    java.lang.String layoutUuid)
4766                    throws com.liferay.portal.kernel.exception.SystemException {
4767                    return getPersistence()
4768                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
4769            }
4770    
4771            /**
4772            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
4773            *
4774            * @param groupId the group ID
4775            * @param articleId the article ID
4776            * @param version the version
4777            * @return the number of matching journal articles
4778            * @throws SystemException if a system exception occurred
4779            */
4780            public static int countByG_A_V(long groupId, java.lang.String articleId,
4781                    double version)
4782                    throws com.liferay.portal.kernel.exception.SystemException {
4783                    return getPersistence().countByG_A_V(groupId, articleId, version);
4784            }
4785    
4786            /**
4787            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
4788            *
4789            * @param groupId the group ID
4790            * @param articleId the article ID
4791            * @param status the status
4792            * @return the number of matching journal articles
4793            * @throws SystemException if a system exception occurred
4794            */
4795            public static int countByG_A_ST(long groupId, java.lang.String articleId,
4796                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4797                    return getPersistence().countByG_A_ST(groupId, articleId, status);
4798            }
4799    
4800            /**
4801            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
4802            *
4803            * @param groupId the group ID
4804            * @param articleId the article ID
4805            * @param statuses the statuses
4806            * @return the number of matching journal articles
4807            * @throws SystemException if a system exception occurred
4808            */
4809            public static int countByG_A_ST(long groupId, java.lang.String articleId,
4810                    int[] statuses)
4811                    throws com.liferay.portal.kernel.exception.SystemException {
4812                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
4813            }
4814    
4815            /**
4816            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
4817            *
4818            * @param groupId the group ID
4819            * @param articleId the article ID
4820            * @param status the status
4821            * @return the number of matching journal articles that the user has permission to view
4822            * @throws SystemException if a system exception occurred
4823            */
4824            public static int filterCountByG_A_ST(long groupId,
4825                    java.lang.String articleId, int status)
4826                    throws com.liferay.portal.kernel.exception.SystemException {
4827                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
4828            }
4829    
4830            /**
4831            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
4832            *
4833            * @param groupId the group ID
4834            * @param articleId the article ID
4835            * @param statuses the statuses
4836            * @return the number of matching journal articles that the user has permission to view
4837            * @throws SystemException if a system exception occurred
4838            */
4839            public static int filterCountByG_A_ST(long groupId,
4840                    java.lang.String articleId, int[] statuses)
4841                    throws com.liferay.portal.kernel.exception.SystemException {
4842                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
4843            }
4844    
4845            /**
4846            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4847            *
4848            * @param groupId the group ID
4849            * @param urlTitle the url title
4850            * @param status the status
4851            * @return the number of matching journal articles
4852            * @throws SystemException if a system exception occurred
4853            */
4854            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
4855                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4856                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
4857            }
4858    
4859            /**
4860            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4861            *
4862            * @param groupId the group ID
4863            * @param urlTitle the url title
4864            * @param status the status
4865            * @return the number of matching journal articles that the user has permission to view
4866            * @throws SystemException if a system exception occurred
4867            */
4868            public static int filterCountByG_UT_ST(long groupId,
4869                    java.lang.String urlTitle, int status)
4870                    throws com.liferay.portal.kernel.exception.SystemException {
4871                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
4872            }
4873    
4874            /**
4875            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4876            *
4877            * @param companyId the company ID
4878            * @param version the version
4879            * @param status the status
4880            * @return the number of matching journal articles
4881            * @throws SystemException if a system exception occurred
4882            */
4883            public static int countByC_V_ST(long companyId, double version, int status)
4884                    throws com.liferay.portal.kernel.exception.SystemException {
4885                    return getPersistence().countByC_V_ST(companyId, version, status);
4886            }
4887    
4888            /**
4889            * Returns the number of journal articles.
4890            *
4891            * @return the number of journal articles
4892            * @throws SystemException if a system exception occurred
4893            */
4894            public static int countAll()
4895                    throws com.liferay.portal.kernel.exception.SystemException {
4896                    return getPersistence().countAll();
4897            }
4898    
4899            public static JournalArticlePersistence getPersistence() {
4900                    if (_persistence == null) {
4901                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
4902    
4903                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
4904                                    "_persistence");
4905                    }
4906    
4907                    return _persistence;
4908            }
4909    
4910            public void setPersistence(JournalArticlePersistence persistence) {
4911                    _persistence = persistence;
4912    
4913                    ReferenceRegistry.registerReference(JournalArticleUtil.class,
4914                            "_persistence");
4915            }
4916    
4917            private static JournalArticlePersistence _persistence;
4918    }