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 structureId = &#63;.
798            *
799            * @param structureId the structure 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> findByStructureId(
804                    java.lang.String structureId)
805                    throws com.liferay.portal.kernel.exception.SystemException {
806                    return getPersistence().findByStructureId(structureId);
807            }
808    
809            /**
810            * Returns a range of all the journal articles where structureId = &#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 structureId the structure 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> findByStructureId(
823                    java.lang.String structureId, int start, int end)
824                    throws com.liferay.portal.kernel.exception.SystemException {
825                    return getPersistence().findByStructureId(structureId, start, end);
826            }
827    
828            /**
829            * Returns an ordered range of all the journal articles where structureId = &#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 structureId the structure 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> findByStructureId(
843                    java.lang.String structureId, int start, int end,
844                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
845                    throws com.liferay.portal.kernel.exception.SystemException {
846                    return getPersistence()
847                                       .findByStructureId(structureId, start, end, orderByComparator);
848            }
849    
850            /**
851            * Returns the first journal article in the ordered set where structureId = &#63;.
852            *
853            * <p>
854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
855            * </p>
856            *
857            * @param structureId the structure ID
858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
859            * @return the first matching journal article
860            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
861            * @throws SystemException if a system exception occurred
862            */
863            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First(
864                    java.lang.String structureId,
865                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
866                    throws com.liferay.portal.kernel.exception.SystemException,
867                            com.liferay.portlet.journal.NoSuchArticleException {
868                    return getPersistence()
869                                       .findByStructureId_First(structureId, orderByComparator);
870            }
871    
872            /**
873            * Returns the last journal article in the ordered set where structureId = &#63;.
874            *
875            * <p>
876            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
877            * </p>
878            *
879            * @param structureId the structure ID
880            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
881            * @return the last matching journal article
882            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
883            * @throws SystemException if a system exception occurred
884            */
885            public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last(
886                    java.lang.String structureId,
887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
888                    throws com.liferay.portal.kernel.exception.SystemException,
889                            com.liferay.portlet.journal.NoSuchArticleException {
890                    return getPersistence()
891                                       .findByStructureId_Last(structureId, orderByComparator);
892            }
893    
894            /**
895            * Returns the journal articles before and after the current journal article in the ordered set where structureId = &#63;.
896            *
897            * <p>
898            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
899            * </p>
900            *
901            * @param id the primary key of the current journal article
902            * @param structureId the structure ID
903            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
904            * @return the previous, current, and next journal article
905            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
906            * @throws SystemException if a system exception occurred
907            */
908            public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext(
909                    long id, java.lang.String structureId,
910                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
911                    throws com.liferay.portal.kernel.exception.SystemException,
912                            com.liferay.portlet.journal.NoSuchArticleException {
913                    return getPersistence()
914                                       .findByStructureId_PrevAndNext(id, structureId,
915                            orderByComparator);
916            }
917    
918            /**
919            * Returns all the journal articles where templateId = &#63;.
920            *
921            * @param templateId the template ID
922            * @return the matching journal articles
923            * @throws SystemException if a system exception occurred
924            */
925            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
926                    java.lang.String templateId)
927                    throws com.liferay.portal.kernel.exception.SystemException {
928                    return getPersistence().findByTemplateId(templateId);
929            }
930    
931            /**
932            * Returns a range of all the journal articles where templateId = &#63;.
933            *
934            * <p>
935            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
936            * </p>
937            *
938            * @param templateId the template ID
939            * @param start the lower bound of the range of journal articles
940            * @param end the upper bound of the range of journal articles (not inclusive)
941            * @return the range of matching journal articles
942            * @throws SystemException if a system exception occurred
943            */
944            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
945                    java.lang.String templateId, int start, int end)
946                    throws com.liferay.portal.kernel.exception.SystemException {
947                    return getPersistence().findByTemplateId(templateId, start, end);
948            }
949    
950            /**
951            * Returns an ordered range of all the journal articles where templateId = &#63;.
952            *
953            * <p>
954            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
955            * </p>
956            *
957            * @param templateId the template ID
958            * @param start the lower bound of the range of journal articles
959            * @param end the upper bound of the range of journal articles (not inclusive)
960            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
961            * @return the ordered range of matching journal articles
962            * @throws SystemException if a system exception occurred
963            */
964            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId(
965                    java.lang.String templateId, int start, int end,
966                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
967                    throws com.liferay.portal.kernel.exception.SystemException {
968                    return getPersistence()
969                                       .findByTemplateId(templateId, start, end, orderByComparator);
970            }
971    
972            /**
973            * Returns the first journal article in the ordered set where templateId = &#63;.
974            *
975            * <p>
976            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
977            * </p>
978            *
979            * @param templateId the template ID
980            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
981            * @return the first matching journal article
982            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
983            * @throws SystemException if a system exception occurred
984            */
985            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First(
986                    java.lang.String templateId,
987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
988                    throws com.liferay.portal.kernel.exception.SystemException,
989                            com.liferay.portlet.journal.NoSuchArticleException {
990                    return getPersistence()
991                                       .findByTemplateId_First(templateId, orderByComparator);
992            }
993    
994            /**
995            * Returns the last journal article in the ordered set where templateId = &#63;.
996            *
997            * <p>
998            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
999            * </p>
1000            *
1001            * @param templateId the template ID
1002            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1003            * @return the last matching journal article
1004            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1005            * @throws SystemException if a system exception occurred
1006            */
1007            public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last(
1008                    java.lang.String templateId,
1009                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1010                    throws com.liferay.portal.kernel.exception.SystemException,
1011                            com.liferay.portlet.journal.NoSuchArticleException {
1012                    return getPersistence()
1013                                       .findByTemplateId_Last(templateId, orderByComparator);
1014            }
1015    
1016            /**
1017            * Returns the journal articles before and after the current journal article in the ordered set where templateId = &#63;.
1018            *
1019            * <p>
1020            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1021            * </p>
1022            *
1023            * @param id the primary key of the current journal article
1024            * @param templateId the template ID
1025            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1026            * @return the previous, current, and next journal article
1027            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1028            * @throws SystemException if a system exception occurred
1029            */
1030            public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext(
1031                    long id, java.lang.String templateId,
1032                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1033                    throws com.liferay.portal.kernel.exception.SystemException,
1034                            com.liferay.portlet.journal.NoSuchArticleException {
1035                    return getPersistence()
1036                                       .findByTemplateId_PrevAndNext(id, templateId,
1037                            orderByComparator);
1038            }
1039    
1040            /**
1041            * Returns all the journal articles where smallImageId = &#63;.
1042            *
1043            * @param smallImageId the small image ID
1044            * @return the matching journal articles
1045            * @throws SystemException if a system exception occurred
1046            */
1047            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1048                    long smallImageId)
1049                    throws com.liferay.portal.kernel.exception.SystemException {
1050                    return getPersistence().findBySmallImageId(smallImageId);
1051            }
1052    
1053            /**
1054            * Returns a range of all the journal articles where smallImageId = &#63;.
1055            *
1056            * <p>
1057            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1058            * </p>
1059            *
1060            * @param smallImageId the small image ID
1061            * @param start the lower bound of the range of journal articles
1062            * @param end the upper bound of the range of journal articles (not inclusive)
1063            * @return the range of matching journal articles
1064            * @throws SystemException if a system exception occurred
1065            */
1066            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1067                    long smallImageId, int start, int end)
1068                    throws com.liferay.portal.kernel.exception.SystemException {
1069                    return getPersistence().findBySmallImageId(smallImageId, start, end);
1070            }
1071    
1072            /**
1073            * Returns an ordered range of all the journal articles where smallImageId = &#63;.
1074            *
1075            * <p>
1076            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1077            * </p>
1078            *
1079            * @param smallImageId the small image ID
1080            * @param start the lower bound of the range of journal articles
1081            * @param end the upper bound of the range of journal articles (not inclusive)
1082            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1083            * @return the ordered range of matching journal articles
1084            * @throws SystemException if a system exception occurred
1085            */
1086            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId(
1087                    long smallImageId, int start, int end,
1088                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1089                    throws com.liferay.portal.kernel.exception.SystemException {
1090                    return getPersistence()
1091                                       .findBySmallImageId(smallImageId, start, end,
1092                            orderByComparator);
1093            }
1094    
1095            /**
1096            * Returns the first journal article in the ordered set where smallImageId = &#63;.
1097            *
1098            * <p>
1099            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1100            * </p>
1101            *
1102            * @param smallImageId the small image ID
1103            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1104            * @return the first matching journal article
1105            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1106            * @throws SystemException if a system exception occurred
1107            */
1108            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First(
1109                    long smallImageId,
1110                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1111                    throws com.liferay.portal.kernel.exception.SystemException,
1112                            com.liferay.portlet.journal.NoSuchArticleException {
1113                    return getPersistence()
1114                                       .findBySmallImageId_First(smallImageId, orderByComparator);
1115            }
1116    
1117            /**
1118            * Returns the last journal article in the ordered set where smallImageId = &#63;.
1119            *
1120            * <p>
1121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1122            * </p>
1123            *
1124            * @param smallImageId the small image ID
1125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1126            * @return the last matching journal article
1127            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last(
1131                    long smallImageId,
1132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1133                    throws com.liferay.portal.kernel.exception.SystemException,
1134                            com.liferay.portlet.journal.NoSuchArticleException {
1135                    return getPersistence()
1136                                       .findBySmallImageId_Last(smallImageId, orderByComparator);
1137            }
1138    
1139            /**
1140            * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = &#63;.
1141            *
1142            * <p>
1143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1144            * </p>
1145            *
1146            * @param id the primary key of the current journal article
1147            * @param smallImageId the small image ID
1148            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1149            * @return the previous, current, and next journal article
1150            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1151            * @throws SystemException if a system exception occurred
1152            */
1153            public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext(
1154                    long id, long smallImageId,
1155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1156                    throws com.liferay.portal.kernel.exception.SystemException,
1157                            com.liferay.portlet.journal.NoSuchArticleException {
1158                    return getPersistence()
1159                                       .findBySmallImageId_PrevAndNext(id, smallImageId,
1160                            orderByComparator);
1161            }
1162    
1163            /**
1164            * Returns all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1165            *
1166            * @param resourcePrimKey the resource prim key
1167            * @param status the status
1168            * @return the matching journal articles
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1172                    long resourcePrimKey, int status)
1173                    throws com.liferay.portal.kernel.exception.SystemException {
1174                    return getPersistence().findByR_ST(resourcePrimKey, status);
1175            }
1176    
1177            /**
1178            * Returns a range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1179            *
1180            * <p>
1181            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1182            * </p>
1183            *
1184            * @param resourcePrimKey the resource prim key
1185            * @param status the status
1186            * @param start the lower bound of the range of journal articles
1187            * @param end the upper bound of the range of journal articles (not inclusive)
1188            * @return the range of matching journal articles
1189            * @throws SystemException if a system exception occurred
1190            */
1191            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1192                    long resourcePrimKey, int status, int start, int end)
1193                    throws com.liferay.portal.kernel.exception.SystemException {
1194                    return getPersistence().findByR_ST(resourcePrimKey, status, start, end);
1195            }
1196    
1197            /**
1198            * Returns an ordered range of all the journal articles where resourcePrimKey = &#63; and status = &#63;.
1199            *
1200            * <p>
1201            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1202            * </p>
1203            *
1204            * @param resourcePrimKey the resource prim key
1205            * @param status the status
1206            * @param start the lower bound of the range of journal articles
1207            * @param end the upper bound of the range of journal articles (not inclusive)
1208            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1209            * @return the ordered range of matching journal articles
1210            * @throws SystemException if a system exception occurred
1211            */
1212            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST(
1213                    long resourcePrimKey, int status, int start, int end,
1214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1215                    throws com.liferay.portal.kernel.exception.SystemException {
1216                    return getPersistence()
1217                                       .findByR_ST(resourcePrimKey, status, start, end,
1218                            orderByComparator);
1219            }
1220    
1221            /**
1222            * Returns the first journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1223            *
1224            * <p>
1225            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1226            * </p>
1227            *
1228            * @param resourcePrimKey the resource prim key
1229            * @param status the status
1230            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1231            * @return the first matching journal article
1232            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1233            * @throws SystemException if a system exception occurred
1234            */
1235            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First(
1236                    long resourcePrimKey, int status,
1237                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1238                    throws com.liferay.portal.kernel.exception.SystemException,
1239                            com.liferay.portlet.journal.NoSuchArticleException {
1240                    return getPersistence()
1241                                       .findByR_ST_First(resourcePrimKey, status, orderByComparator);
1242            }
1243    
1244            /**
1245            * Returns the last journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1246            *
1247            * <p>
1248            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1249            * </p>
1250            *
1251            * @param resourcePrimKey the resource prim key
1252            * @param status the status
1253            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1254            * @return the last matching journal article
1255            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1256            * @throws SystemException if a system exception occurred
1257            */
1258            public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last(
1259                    long resourcePrimKey, int status,
1260                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1261                    throws com.liferay.portal.kernel.exception.SystemException,
1262                            com.liferay.portlet.journal.NoSuchArticleException {
1263                    return getPersistence()
1264                                       .findByR_ST_Last(resourcePrimKey, status, orderByComparator);
1265            }
1266    
1267            /**
1268            * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = &#63; and status = &#63;.
1269            *
1270            * <p>
1271            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1272            * </p>
1273            *
1274            * @param id the primary key of the current journal article
1275            * @param resourcePrimKey the resource prim key
1276            * @param status the status
1277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1278            * @return the previous, current, and next journal article
1279            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1280            * @throws SystemException if a system exception occurred
1281            */
1282            public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext(
1283                    long id, long resourcePrimKey, int status,
1284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1285                    throws com.liferay.portal.kernel.exception.SystemException,
1286                            com.liferay.portlet.journal.NoSuchArticleException {
1287                    return getPersistence()
1288                                       .findByR_ST_PrevAndNext(id, resourcePrimKey, status,
1289                            orderByComparator);
1290            }
1291    
1292            /**
1293            * Returns all the journal articles where groupId = &#63; and articleId = &#63;.
1294            *
1295            * @param groupId the group ID
1296            * @param articleId the article ID
1297            * @return the matching journal articles
1298            * @throws SystemException if a system exception occurred
1299            */
1300            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1301                    long groupId, java.lang.String articleId)
1302                    throws com.liferay.portal.kernel.exception.SystemException {
1303                    return getPersistence().findByG_A(groupId, articleId);
1304            }
1305    
1306            /**
1307            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63;.
1308            *
1309            * <p>
1310            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1311            * </p>
1312            *
1313            * @param groupId the group ID
1314            * @param articleId the article ID
1315            * @param start the lower bound of the range of journal articles
1316            * @param end the upper bound of the range of journal articles (not inclusive)
1317            * @return the range of matching journal articles
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1321                    long groupId, java.lang.String articleId, int start, int end)
1322                    throws com.liferay.portal.kernel.exception.SystemException {
1323                    return getPersistence().findByG_A(groupId, articleId, start, end);
1324            }
1325    
1326            /**
1327            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63;.
1328            *
1329            * <p>
1330            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1331            * </p>
1332            *
1333            * @param groupId the group ID
1334            * @param articleId the article ID
1335            * @param start the lower bound of the range of journal articles
1336            * @param end the upper bound of the range of journal articles (not inclusive)
1337            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1338            * @return the ordered range of matching journal articles
1339            * @throws SystemException if a system exception occurred
1340            */
1341            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A(
1342                    long groupId, java.lang.String articleId, int start, int end,
1343                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1344                    throws com.liferay.portal.kernel.exception.SystemException {
1345                    return getPersistence()
1346                                       .findByG_A(groupId, articleId, start, end, orderByComparator);
1347            }
1348    
1349            /**
1350            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1351            *
1352            * <p>
1353            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1354            * </p>
1355            *
1356            * @param groupId the group ID
1357            * @param articleId the article ID
1358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1359            * @return the first matching journal article
1360            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First(
1364                    long groupId, java.lang.String articleId,
1365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1366                    throws com.liferay.portal.kernel.exception.SystemException,
1367                            com.liferay.portlet.journal.NoSuchArticleException {
1368                    return getPersistence()
1369                                       .findByG_A_First(groupId, articleId, orderByComparator);
1370            }
1371    
1372            /**
1373            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1374            *
1375            * <p>
1376            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1377            * </p>
1378            *
1379            * @param groupId the group ID
1380            * @param articleId the article ID
1381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1382            * @return the last matching journal article
1383            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1384            * @throws SystemException if a system exception occurred
1385            */
1386            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last(
1387                    long groupId, java.lang.String articleId,
1388                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1389                    throws com.liferay.portal.kernel.exception.SystemException,
1390                            com.liferay.portlet.journal.NoSuchArticleException {
1391                    return getPersistence()
1392                                       .findByG_A_Last(groupId, articleId, orderByComparator);
1393            }
1394    
1395            /**
1396            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63;.
1397            *
1398            * <p>
1399            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1400            * </p>
1401            *
1402            * @param id the primary key of the current journal article
1403            * @param groupId the group ID
1404            * @param articleId the article ID
1405            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1406            * @return the previous, current, and next journal article
1407            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1408            * @throws SystemException if a system exception occurred
1409            */
1410            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext(
1411                    long id, long groupId, java.lang.String articleId,
1412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1413                    throws com.liferay.portal.kernel.exception.SystemException,
1414                            com.liferay.portlet.journal.NoSuchArticleException {
1415                    return getPersistence()
1416                                       .findByG_A_PrevAndNext(id, groupId, articleId,
1417                            orderByComparator);
1418            }
1419    
1420            /**
1421            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1422            *
1423            * @param groupId the group ID
1424            * @param articleId the article ID
1425            * @return the matching journal articles that the user has permission to view
1426            * @throws SystemException if a system exception occurred
1427            */
1428            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1429                    long groupId, java.lang.String articleId)
1430                    throws com.liferay.portal.kernel.exception.SystemException {
1431                    return getPersistence().filterFindByG_A(groupId, articleId);
1432            }
1433    
1434            /**
1435            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
1436            *
1437            * <p>
1438            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1439            * </p>
1440            *
1441            * @param groupId the group ID
1442            * @param articleId the article ID
1443            * @param start the lower bound of the range of journal articles
1444            * @param end the upper bound of the range of journal articles (not inclusive)
1445            * @return the range of matching journal articles that the user has permission to view
1446            * @throws SystemException if a system exception occurred
1447            */
1448            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1449                    long groupId, java.lang.String articleId, int start, int end)
1450                    throws com.liferay.portal.kernel.exception.SystemException {
1451                    return getPersistence().filterFindByG_A(groupId, articleId, start, end);
1452            }
1453    
1454            /**
1455            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and articleId = &#63;.
1456            *
1457            * <p>
1458            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1459            * </p>
1460            *
1461            * @param groupId the group ID
1462            * @param articleId the article ID
1463            * @param start the lower bound of the range of journal articles
1464            * @param end the upper bound of the range of journal articles (not inclusive)
1465            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1466            * @return the ordered range of matching journal articles that the user has permission to view
1467            * @throws SystemException if a system exception occurred
1468            */
1469            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A(
1470                    long groupId, java.lang.String articleId, int start, int end,
1471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1472                    throws com.liferay.portal.kernel.exception.SystemException {
1473                    return getPersistence()
1474                                       .filterFindByG_A(groupId, articleId, start, end,
1475                            orderByComparator);
1476            }
1477    
1478            /**
1479            * 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;.
1480            *
1481            * @param id the primary key of the current journal article
1482            * @param groupId the group ID
1483            * @param articleId the article ID
1484            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1485            * @return the previous, current, and next journal article
1486            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1487            * @throws SystemException if a system exception occurred
1488            */
1489            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext(
1490                    long id, long groupId, java.lang.String articleId,
1491                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1492                    throws com.liferay.portal.kernel.exception.SystemException,
1493                            com.liferay.portlet.journal.NoSuchArticleException {
1494                    return getPersistence()
1495                                       .filterFindByG_A_PrevAndNext(id, groupId, articleId,
1496                            orderByComparator);
1497            }
1498    
1499            /**
1500            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63;.
1501            *
1502            * @param groupId the group ID
1503            * @param urlTitle the url title
1504            * @return the matching journal articles
1505            * @throws SystemException if a system exception occurred
1506            */
1507            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1508                    long groupId, java.lang.String urlTitle)
1509                    throws com.liferay.portal.kernel.exception.SystemException {
1510                    return getPersistence().findByG_UT(groupId, urlTitle);
1511            }
1512    
1513            /**
1514            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1515            *
1516            * <p>
1517            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1518            * </p>
1519            *
1520            * @param groupId the group ID
1521            * @param urlTitle the url title
1522            * @param start the lower bound of the range of journal articles
1523            * @param end the upper bound of the range of journal articles (not inclusive)
1524            * @return the range of matching journal articles
1525            * @throws SystemException if a system exception occurred
1526            */
1527            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1528                    long groupId, java.lang.String urlTitle, int start, int end)
1529                    throws com.liferay.portal.kernel.exception.SystemException {
1530                    return getPersistence().findByG_UT(groupId, urlTitle, start, end);
1531            }
1532    
1533            /**
1534            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63;.
1535            *
1536            * <p>
1537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1538            * </p>
1539            *
1540            * @param groupId the group ID
1541            * @param urlTitle the url title
1542            * @param start the lower bound of the range of journal articles
1543            * @param end the upper bound of the range of journal articles (not inclusive)
1544            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1545            * @return the ordered range of matching journal articles
1546            * @throws SystemException if a system exception occurred
1547            */
1548            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT(
1549                    long groupId, java.lang.String urlTitle, int start, int end,
1550                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1551                    throws com.liferay.portal.kernel.exception.SystemException {
1552                    return getPersistence()
1553                                       .findByG_UT(groupId, urlTitle, start, end, orderByComparator);
1554            }
1555    
1556            /**
1557            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1558            *
1559            * <p>
1560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1561            * </p>
1562            *
1563            * @param groupId the group ID
1564            * @param urlTitle the url title
1565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1566            * @return the first matching journal article
1567            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1568            * @throws SystemException if a system exception occurred
1569            */
1570            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First(
1571                    long groupId, java.lang.String urlTitle,
1572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1573                    throws com.liferay.portal.kernel.exception.SystemException,
1574                            com.liferay.portlet.journal.NoSuchArticleException {
1575                    return getPersistence()
1576                                       .findByG_UT_First(groupId, urlTitle, orderByComparator);
1577            }
1578    
1579            /**
1580            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1581            *
1582            * <p>
1583            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1584            * </p>
1585            *
1586            * @param groupId the group ID
1587            * @param urlTitle the url title
1588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1589            * @return the last matching journal article
1590            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1591            * @throws SystemException if a system exception occurred
1592            */
1593            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last(
1594                    long groupId, java.lang.String urlTitle,
1595                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1596                    throws com.liferay.portal.kernel.exception.SystemException,
1597                            com.liferay.portlet.journal.NoSuchArticleException {
1598                    return getPersistence()
1599                                       .findByG_UT_Last(groupId, urlTitle, orderByComparator);
1600            }
1601    
1602            /**
1603            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63;.
1604            *
1605            * <p>
1606            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1607            * </p>
1608            *
1609            * @param id the primary key of the current journal article
1610            * @param groupId the group ID
1611            * @param urlTitle the url title
1612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1613            * @return the previous, current, and next journal article
1614            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1615            * @throws SystemException if a system exception occurred
1616            */
1617            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext(
1618                    long id, long groupId, java.lang.String urlTitle,
1619                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1620                    throws com.liferay.portal.kernel.exception.SystemException,
1621                            com.liferay.portlet.journal.NoSuchArticleException {
1622                    return getPersistence()
1623                                       .findByG_UT_PrevAndNext(id, groupId, urlTitle,
1624                            orderByComparator);
1625            }
1626    
1627            /**
1628            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1629            *
1630            * @param groupId the group ID
1631            * @param urlTitle the url title
1632            * @return the matching journal articles that the user has permission to view
1633            * @throws SystemException if a system exception occurred
1634            */
1635            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1636                    long groupId, java.lang.String urlTitle)
1637                    throws com.liferay.portal.kernel.exception.SystemException {
1638                    return getPersistence().filterFindByG_UT(groupId, urlTitle);
1639            }
1640    
1641            /**
1642            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
1643            *
1644            * <p>
1645            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1646            * </p>
1647            *
1648            * @param groupId the group ID
1649            * @param urlTitle the url title
1650            * @param start the lower bound of the range of journal articles
1651            * @param end the upper bound of the range of journal articles (not inclusive)
1652            * @return the range of matching journal articles that the user has permission to view
1653            * @throws SystemException if a system exception occurred
1654            */
1655            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1656                    long groupId, java.lang.String urlTitle, int start, int end)
1657                    throws com.liferay.portal.kernel.exception.SystemException {
1658                    return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end);
1659            }
1660    
1661            /**
1662            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and urlTitle = &#63;.
1663            *
1664            * <p>
1665            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1666            * </p>
1667            *
1668            * @param groupId the group ID
1669            * @param urlTitle the url title
1670            * @param start the lower bound of the range of journal articles
1671            * @param end the upper bound of the range of journal articles (not inclusive)
1672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1673            * @return the ordered range of matching journal articles that the user has permission to view
1674            * @throws SystemException if a system exception occurred
1675            */
1676            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT(
1677                    long groupId, java.lang.String urlTitle, int start, int end,
1678                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1679                    throws com.liferay.portal.kernel.exception.SystemException {
1680                    return getPersistence()
1681                                       .filterFindByG_UT(groupId, urlTitle, start, end,
1682                            orderByComparator);
1683            }
1684    
1685            /**
1686            * 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;.
1687            *
1688            * @param id the primary key of the current journal article
1689            * @param groupId the group ID
1690            * @param urlTitle the url title
1691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1692            * @return the previous, current, and next journal article
1693            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1694            * @throws SystemException if a system exception occurred
1695            */
1696            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext(
1697                    long id, long groupId, java.lang.String urlTitle,
1698                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1699                    throws com.liferay.portal.kernel.exception.SystemException,
1700                            com.liferay.portlet.journal.NoSuchArticleException {
1701                    return getPersistence()
1702                                       .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle,
1703                            orderByComparator);
1704            }
1705    
1706            /**
1707            * Returns all the journal articles where groupId = &#63; and structureId = &#63;.
1708            *
1709            * @param groupId the group ID
1710            * @param structureId the structure ID
1711            * @return the matching journal articles
1712            * @throws SystemException if a system exception occurred
1713            */
1714            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1715                    long groupId, java.lang.String structureId)
1716                    throws com.liferay.portal.kernel.exception.SystemException {
1717                    return getPersistence().findByG_S(groupId, structureId);
1718            }
1719    
1720            /**
1721            * Returns a range of all the journal articles where groupId = &#63; and structureId = &#63;.
1722            *
1723            * <p>
1724            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1725            * </p>
1726            *
1727            * @param groupId the group ID
1728            * @param structureId the structure ID
1729            * @param start the lower bound of the range of journal articles
1730            * @param end the upper bound of the range of journal articles (not inclusive)
1731            * @return the range of matching journal articles
1732            * @throws SystemException if a system exception occurred
1733            */
1734            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1735                    long groupId, java.lang.String structureId, int start, int end)
1736                    throws com.liferay.portal.kernel.exception.SystemException {
1737                    return getPersistence().findByG_S(groupId, structureId, start, end);
1738            }
1739    
1740            /**
1741            * Returns an ordered range of all the journal articles where groupId = &#63; and structureId = &#63;.
1742            *
1743            * <p>
1744            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1745            * </p>
1746            *
1747            * @param groupId the group ID
1748            * @param structureId the structure ID
1749            * @param start the lower bound of the range of journal articles
1750            * @param end the upper bound of the range of journal articles (not inclusive)
1751            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1752            * @return the ordered range of matching journal articles
1753            * @throws SystemException if a system exception occurred
1754            */
1755            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S(
1756                    long groupId, java.lang.String structureId, int start, int end,
1757                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1758                    throws com.liferay.portal.kernel.exception.SystemException {
1759                    return getPersistence()
1760                                       .findByG_S(groupId, structureId, start, end,
1761                            orderByComparator);
1762            }
1763    
1764            /**
1765            * Returns the first journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1766            *
1767            * <p>
1768            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1769            * </p>
1770            *
1771            * @param groupId the group ID
1772            * @param structureId the structure ID
1773            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1774            * @return the first matching journal article
1775            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1776            * @throws SystemException if a system exception occurred
1777            */
1778            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First(
1779                    long groupId, java.lang.String structureId,
1780                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1781                    throws com.liferay.portal.kernel.exception.SystemException,
1782                            com.liferay.portlet.journal.NoSuchArticleException {
1783                    return getPersistence()
1784                                       .findByG_S_First(groupId, structureId, orderByComparator);
1785            }
1786    
1787            /**
1788            * Returns the last journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1789            *
1790            * <p>
1791            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1792            * </p>
1793            *
1794            * @param groupId the group ID
1795            * @param structureId the structure ID
1796            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1797            * @return the last matching journal article
1798            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1799            * @throws SystemException if a system exception occurred
1800            */
1801            public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last(
1802                    long groupId, java.lang.String structureId,
1803                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1804                    throws com.liferay.portal.kernel.exception.SystemException,
1805                            com.liferay.portlet.journal.NoSuchArticleException {
1806                    return getPersistence()
1807                                       .findByG_S_Last(groupId, structureId, orderByComparator);
1808            }
1809    
1810            /**
1811            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and structureId = &#63;.
1812            *
1813            * <p>
1814            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1815            * </p>
1816            *
1817            * @param id the primary key of the current journal article
1818            * @param groupId the group ID
1819            * @param structureId the structure ID
1820            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1821            * @return the previous, current, and next journal article
1822            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1823            * @throws SystemException if a system exception occurred
1824            */
1825            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext(
1826                    long id, long groupId, java.lang.String structureId,
1827                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1828                    throws com.liferay.portal.kernel.exception.SystemException,
1829                            com.liferay.portlet.journal.NoSuchArticleException {
1830                    return getPersistence()
1831                                       .findByG_S_PrevAndNext(id, groupId, structureId,
1832                            orderByComparator);
1833            }
1834    
1835            /**
1836            * Returns all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1837            *
1838            * @param groupId the group ID
1839            * @param structureId the structure ID
1840            * @return the matching journal articles that the user has permission to view
1841            * @throws SystemException if a system exception occurred
1842            */
1843            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1844                    long groupId, java.lang.String structureId)
1845                    throws com.liferay.portal.kernel.exception.SystemException {
1846                    return getPersistence().filterFindByG_S(groupId, structureId);
1847            }
1848    
1849            /**
1850            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
1851            *
1852            * <p>
1853            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1854            * </p>
1855            *
1856            * @param groupId the group ID
1857            * @param structureId the structure ID
1858            * @param start the lower bound of the range of journal articles
1859            * @param end the upper bound of the range of journal articles (not inclusive)
1860            * @return the range of matching journal articles that the user has permission to view
1861            * @throws SystemException if a system exception occurred
1862            */
1863            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1864                    long groupId, java.lang.String structureId, int start, int end)
1865                    throws com.liferay.portal.kernel.exception.SystemException {
1866                    return getPersistence().filterFindByG_S(groupId, structureId, start, end);
1867            }
1868    
1869            /**
1870            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and structureId = &#63;.
1871            *
1872            * <p>
1873            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1874            * </p>
1875            *
1876            * @param groupId the group ID
1877            * @param structureId the structure ID
1878            * @param start the lower bound of the range of journal articles
1879            * @param end the upper bound of the range of journal articles (not inclusive)
1880            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1881            * @return the ordered range of matching journal articles that the user has permission to view
1882            * @throws SystemException if a system exception occurred
1883            */
1884            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S(
1885                    long groupId, java.lang.String structureId, int start, int end,
1886                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1887                    throws com.liferay.portal.kernel.exception.SystemException {
1888                    return getPersistence()
1889                                       .filterFindByG_S(groupId, structureId, start, end,
1890                            orderByComparator);
1891            }
1892    
1893            /**
1894            * 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;.
1895            *
1896            * @param id the primary key of the current journal article
1897            * @param groupId the group ID
1898            * @param structureId the structure ID
1899            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1900            * @return the previous, current, and next journal article
1901            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
1902            * @throws SystemException if a system exception occurred
1903            */
1904            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext(
1905                    long id, long groupId, java.lang.String structureId,
1906                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1907                    throws com.liferay.portal.kernel.exception.SystemException,
1908                            com.liferay.portlet.journal.NoSuchArticleException {
1909                    return getPersistence()
1910                                       .filterFindByG_S_PrevAndNext(id, groupId, structureId,
1911                            orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns all the journal articles where groupId = &#63; and templateId = &#63;.
1916            *
1917            * @param groupId the group ID
1918            * @param templateId the template ID
1919            * @return the matching journal articles
1920            * @throws SystemException if a system exception occurred
1921            */
1922            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1923                    long groupId, java.lang.String templateId)
1924                    throws com.liferay.portal.kernel.exception.SystemException {
1925                    return getPersistence().findByG_T(groupId, templateId);
1926            }
1927    
1928            /**
1929            * Returns a range of all the journal articles where groupId = &#63; and templateId = &#63;.
1930            *
1931            * <p>
1932            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1933            * </p>
1934            *
1935            * @param groupId the group ID
1936            * @param templateId the template ID
1937            * @param start the lower bound of the range of journal articles
1938            * @param end the upper bound of the range of journal articles (not inclusive)
1939            * @return the range of matching journal articles
1940            * @throws SystemException if a system exception occurred
1941            */
1942            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1943                    long groupId, java.lang.String templateId, int start, int end)
1944                    throws com.liferay.portal.kernel.exception.SystemException {
1945                    return getPersistence().findByG_T(groupId, templateId, start, end);
1946            }
1947    
1948            /**
1949            * Returns an ordered range of all the journal articles where groupId = &#63; and templateId = &#63;.
1950            *
1951            * <p>
1952            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1953            * </p>
1954            *
1955            * @param groupId the group ID
1956            * @param templateId the template ID
1957            * @param start the lower bound of the range of journal articles
1958            * @param end the upper bound of the range of journal articles (not inclusive)
1959            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1960            * @return the ordered range of matching journal articles
1961            * @throws SystemException if a system exception occurred
1962            */
1963            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T(
1964                    long groupId, java.lang.String templateId, int start, int end,
1965                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1966                    throws com.liferay.portal.kernel.exception.SystemException {
1967                    return getPersistence()
1968                                       .findByG_T(groupId, templateId, start, end, orderByComparator);
1969            }
1970    
1971            /**
1972            * Returns the first journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1973            *
1974            * <p>
1975            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1976            * </p>
1977            *
1978            * @param groupId the group ID
1979            * @param templateId the template ID
1980            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1981            * @return the first matching journal article
1982            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
1983            * @throws SystemException if a system exception occurred
1984            */
1985            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First(
1986                    long groupId, java.lang.String templateId,
1987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1988                    throws com.liferay.portal.kernel.exception.SystemException,
1989                            com.liferay.portlet.journal.NoSuchArticleException {
1990                    return getPersistence()
1991                                       .findByG_T_First(groupId, templateId, orderByComparator);
1992            }
1993    
1994            /**
1995            * Returns the last journal article in the ordered set where groupId = &#63; and templateId = &#63;.
1996            *
1997            * <p>
1998            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1999            * </p>
2000            *
2001            * @param groupId the group ID
2002            * @param templateId the template ID
2003            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2004            * @return the last matching journal article
2005            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last(
2009                    long groupId, java.lang.String templateId,
2010                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2011                    throws com.liferay.portal.kernel.exception.SystemException,
2012                            com.liferay.portlet.journal.NoSuchArticleException {
2013                    return getPersistence()
2014                                       .findByG_T_Last(groupId, templateId, orderByComparator);
2015            }
2016    
2017            /**
2018            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and templateId = &#63;.
2019            *
2020            * <p>
2021            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2022            * </p>
2023            *
2024            * @param id the primary key of the current journal article
2025            * @param groupId the group ID
2026            * @param templateId the template ID
2027            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2028            * @return the previous, current, and next journal article
2029            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2030            * @throws SystemException if a system exception occurred
2031            */
2032            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext(
2033                    long id, long groupId, java.lang.String templateId,
2034                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2035                    throws com.liferay.portal.kernel.exception.SystemException,
2036                            com.liferay.portlet.journal.NoSuchArticleException {
2037                    return getPersistence()
2038                                       .findByG_T_PrevAndNext(id, groupId, templateId,
2039                            orderByComparator);
2040            }
2041    
2042            /**
2043            * Returns all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
2044            *
2045            * @param groupId the group ID
2046            * @param templateId the template ID
2047            * @return the matching journal articles that the user has permission to view
2048            * @throws SystemException if a system exception occurred
2049            */
2050            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
2051                    long groupId, java.lang.String templateId)
2052                    throws com.liferay.portal.kernel.exception.SystemException {
2053                    return getPersistence().filterFindByG_T(groupId, templateId);
2054            }
2055    
2056            /**
2057            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
2058            *
2059            * <p>
2060            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2061            * </p>
2062            *
2063            * @param groupId the group ID
2064            * @param templateId the template ID
2065            * @param start the lower bound of the range of journal articles
2066            * @param end the upper bound of the range of journal articles (not inclusive)
2067            * @return the range of matching journal articles that the user has permission to view
2068            * @throws SystemException if a system exception occurred
2069            */
2070            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
2071                    long groupId, java.lang.String templateId, int start, int end)
2072                    throws com.liferay.portal.kernel.exception.SystemException {
2073                    return getPersistence().filterFindByG_T(groupId, templateId, start, end);
2074            }
2075    
2076            /**
2077            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and templateId = &#63;.
2078            *
2079            * <p>
2080            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2081            * </p>
2082            *
2083            * @param groupId the group ID
2084            * @param templateId the template ID
2085            * @param start the lower bound of the range of journal articles
2086            * @param end the upper bound of the range of journal articles (not inclusive)
2087            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2088            * @return the ordered range of matching journal articles that the user has permission to view
2089            * @throws SystemException if a system exception occurred
2090            */
2091            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T(
2092                    long groupId, java.lang.String templateId, int start, int end,
2093                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2094                    throws com.liferay.portal.kernel.exception.SystemException {
2095                    return getPersistence()
2096                                       .filterFindByG_T(groupId, templateId, start, end,
2097                            orderByComparator);
2098            }
2099    
2100            /**
2101            * 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;.
2102            *
2103            * @param id the primary key of the current journal article
2104            * @param groupId the group ID
2105            * @param templateId the template ID
2106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2107            * @return the previous, current, and next journal article
2108            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2109            * @throws SystemException if a system exception occurred
2110            */
2111            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext(
2112                    long id, long groupId, java.lang.String templateId,
2113                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2114                    throws com.liferay.portal.kernel.exception.SystemException,
2115                            com.liferay.portlet.journal.NoSuchArticleException {
2116                    return getPersistence()
2117                                       .filterFindByG_T_PrevAndNext(id, groupId, templateId,
2118                            orderByComparator);
2119            }
2120    
2121            /**
2122            * Returns all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2123            *
2124            * @param groupId the group ID
2125            * @param layoutUuid the layout uuid
2126            * @return the matching journal articles
2127            * @throws SystemException if a system exception occurred
2128            */
2129            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
2130                    long groupId, java.lang.String layoutUuid)
2131                    throws com.liferay.portal.kernel.exception.SystemException {
2132                    return getPersistence().findByG_L(groupId, layoutUuid);
2133            }
2134    
2135            /**
2136            * Returns a range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2137            *
2138            * <p>
2139            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2140            * </p>
2141            *
2142            * @param groupId the group ID
2143            * @param layoutUuid the layout uuid
2144            * @param start the lower bound of the range of journal articles
2145            * @param end the upper bound of the range of journal articles (not inclusive)
2146            * @return the range of matching journal articles
2147            * @throws SystemException if a system exception occurred
2148            */
2149            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
2150                    long groupId, java.lang.String layoutUuid, int start, int end)
2151                    throws com.liferay.portal.kernel.exception.SystemException {
2152                    return getPersistence().findByG_L(groupId, layoutUuid, start, end);
2153            }
2154    
2155            /**
2156            * Returns an ordered range of all the journal articles where groupId = &#63; and layoutUuid = &#63;.
2157            *
2158            * <p>
2159            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2160            * </p>
2161            *
2162            * @param groupId the group ID
2163            * @param layoutUuid the layout uuid
2164            * @param start the lower bound of the range of journal articles
2165            * @param end the upper bound of the range of journal articles (not inclusive)
2166            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2167            * @return the ordered range of matching journal articles
2168            * @throws SystemException if a system exception occurred
2169            */
2170            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L(
2171                    long groupId, java.lang.String layoutUuid, int start, int end,
2172                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2173                    throws com.liferay.portal.kernel.exception.SystemException {
2174                    return getPersistence()
2175                                       .findByG_L(groupId, layoutUuid, start, end, orderByComparator);
2176            }
2177    
2178            /**
2179            * Returns the first journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2180            *
2181            * <p>
2182            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2183            * </p>
2184            *
2185            * @param groupId the group ID
2186            * @param layoutUuid the layout uuid
2187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2188            * @return the first matching journal article
2189            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2190            * @throws SystemException if a system exception occurred
2191            */
2192            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First(
2193                    long groupId, java.lang.String layoutUuid,
2194                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2195                    throws com.liferay.portal.kernel.exception.SystemException,
2196                            com.liferay.portlet.journal.NoSuchArticleException {
2197                    return getPersistence()
2198                                       .findByG_L_First(groupId, layoutUuid, orderByComparator);
2199            }
2200    
2201            /**
2202            * Returns the last journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2203            *
2204            * <p>
2205            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2206            * </p>
2207            *
2208            * @param groupId the group ID
2209            * @param layoutUuid the layout uuid
2210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2211            * @return the last matching journal article
2212            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2213            * @throws SystemException if a system exception occurred
2214            */
2215            public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last(
2216                    long groupId, java.lang.String layoutUuid,
2217                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2218                    throws com.liferay.portal.kernel.exception.SystemException,
2219                            com.liferay.portlet.journal.NoSuchArticleException {
2220                    return getPersistence()
2221                                       .findByG_L_Last(groupId, layoutUuid, orderByComparator);
2222            }
2223    
2224            /**
2225            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and layoutUuid = &#63;.
2226            *
2227            * <p>
2228            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2229            * </p>
2230            *
2231            * @param id the primary key of the current journal article
2232            * @param groupId the group ID
2233            * @param layoutUuid the layout uuid
2234            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2235            * @return the previous, current, and next journal article
2236            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2237            * @throws SystemException if a system exception occurred
2238            */
2239            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext(
2240                    long id, long groupId, java.lang.String layoutUuid,
2241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2242                    throws com.liferay.portal.kernel.exception.SystemException,
2243                            com.liferay.portlet.journal.NoSuchArticleException {
2244                    return getPersistence()
2245                                       .findByG_L_PrevAndNext(id, groupId, layoutUuid,
2246                            orderByComparator);
2247            }
2248    
2249            /**
2250            * Returns all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2251            *
2252            * @param groupId the group ID
2253            * @param layoutUuid the layout uuid
2254            * @return the matching journal articles that the user has permission to view
2255            * @throws SystemException if a system exception occurred
2256            */
2257            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2258                    long groupId, java.lang.String layoutUuid)
2259                    throws com.liferay.portal.kernel.exception.SystemException {
2260                    return getPersistence().filterFindByG_L(groupId, layoutUuid);
2261            }
2262    
2263            /**
2264            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
2265            *
2266            * <p>
2267            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2268            * </p>
2269            *
2270            * @param groupId the group ID
2271            * @param layoutUuid the layout uuid
2272            * @param start the lower bound of the range of journal articles
2273            * @param end the upper bound of the range of journal articles (not inclusive)
2274            * @return the range of matching journal articles that the user has permission to view
2275            * @throws SystemException if a system exception occurred
2276            */
2277            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2278                    long groupId, java.lang.String layoutUuid, int start, int end)
2279                    throws com.liferay.portal.kernel.exception.SystemException {
2280                    return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end);
2281            }
2282    
2283            /**
2284            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and layoutUuid = &#63;.
2285            *
2286            * <p>
2287            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2288            * </p>
2289            *
2290            * @param groupId the group ID
2291            * @param layoutUuid the layout uuid
2292            * @param start the lower bound of the range of journal articles
2293            * @param end the upper bound of the range of journal articles (not inclusive)
2294            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2295            * @return the ordered range of matching journal articles that the user has permission to view
2296            * @throws SystemException if a system exception occurred
2297            */
2298            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L(
2299                    long groupId, java.lang.String layoutUuid, int start, int end,
2300                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2301                    throws com.liferay.portal.kernel.exception.SystemException {
2302                    return getPersistence()
2303                                       .filterFindByG_L(groupId, layoutUuid, start, end,
2304                            orderByComparator);
2305            }
2306    
2307            /**
2308            * 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;.
2309            *
2310            * @param id the primary key of the current journal article
2311            * @param groupId the group ID
2312            * @param layoutUuid the layout uuid
2313            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2314            * @return the previous, current, and next journal article
2315            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2316            * @throws SystemException if a system exception occurred
2317            */
2318            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext(
2319                    long id, long groupId, java.lang.String layoutUuid,
2320                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2321                    throws com.liferay.portal.kernel.exception.SystemException,
2322                            com.liferay.portlet.journal.NoSuchArticleException {
2323                    return getPersistence()
2324                                       .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid,
2325                            orderByComparator);
2326            }
2327    
2328            /**
2329            * Returns all the journal articles where groupId = &#63; and status = &#63;.
2330            *
2331            * @param groupId the group ID
2332            * @param status the status
2333            * @return the matching journal articles
2334            * @throws SystemException if a system exception occurred
2335            */
2336            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2337                    long groupId, int status)
2338                    throws com.liferay.portal.kernel.exception.SystemException {
2339                    return getPersistence().findByG_ST(groupId, status);
2340            }
2341    
2342            /**
2343            * Returns a range of all the journal articles where groupId = &#63; and status = &#63;.
2344            *
2345            * <p>
2346            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2347            * </p>
2348            *
2349            * @param groupId the group ID
2350            * @param status the status
2351            * @param start the lower bound of the range of journal articles
2352            * @param end the upper bound of the range of journal articles (not inclusive)
2353            * @return the range of matching journal articles
2354            * @throws SystemException if a system exception occurred
2355            */
2356            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2357                    long groupId, int status, int start, int end)
2358                    throws com.liferay.portal.kernel.exception.SystemException {
2359                    return getPersistence().findByG_ST(groupId, status, start, end);
2360            }
2361    
2362            /**
2363            * Returns an ordered range of all the journal articles where groupId = &#63; and status = &#63;.
2364            *
2365            * <p>
2366            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2367            * </p>
2368            *
2369            * @param groupId the group ID
2370            * @param status the status
2371            * @param start the lower bound of the range of journal articles
2372            * @param end the upper bound of the range of journal articles (not inclusive)
2373            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2374            * @return the ordered range of matching journal articles
2375            * @throws SystemException if a system exception occurred
2376            */
2377            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST(
2378                    long groupId, int status, int start, int end,
2379                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2380                    throws com.liferay.portal.kernel.exception.SystemException {
2381                    return getPersistence()
2382                                       .findByG_ST(groupId, status, start, end, orderByComparator);
2383            }
2384    
2385            /**
2386            * Returns the first journal article in the ordered set where groupId = &#63; and status = &#63;.
2387            *
2388            * <p>
2389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2390            * </p>
2391            *
2392            * @param groupId the group ID
2393            * @param status the status
2394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2395            * @return the first matching journal article
2396            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2397            * @throws SystemException if a system exception occurred
2398            */
2399            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First(
2400                    long groupId, int status,
2401                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2402                    throws com.liferay.portal.kernel.exception.SystemException,
2403                            com.liferay.portlet.journal.NoSuchArticleException {
2404                    return getPersistence()
2405                                       .findByG_ST_First(groupId, status, orderByComparator);
2406            }
2407    
2408            /**
2409            * Returns the last journal article in the ordered set where groupId = &#63; and status = &#63;.
2410            *
2411            * <p>
2412            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2413            * </p>
2414            *
2415            * @param groupId the group ID
2416            * @param status the status
2417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2418            * @return the last matching journal article
2419            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2420            * @throws SystemException if a system exception occurred
2421            */
2422            public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last(
2423                    long groupId, int status,
2424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2425                    throws com.liferay.portal.kernel.exception.SystemException,
2426                            com.liferay.portlet.journal.NoSuchArticleException {
2427                    return getPersistence()
2428                                       .findByG_ST_Last(groupId, status, orderByComparator);
2429            }
2430    
2431            /**
2432            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and status = &#63;.
2433            *
2434            * <p>
2435            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2436            * </p>
2437            *
2438            * @param id the primary key of the current journal article
2439            * @param groupId the group ID
2440            * @param status the status
2441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2442            * @return the previous, current, and next journal article
2443            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2444            * @throws SystemException if a system exception occurred
2445            */
2446            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext(
2447                    long id, long groupId, int status,
2448                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2449                    throws com.liferay.portal.kernel.exception.SystemException,
2450                            com.liferay.portlet.journal.NoSuchArticleException {
2451                    return getPersistence()
2452                                       .findByG_ST_PrevAndNext(id, groupId, status,
2453                            orderByComparator);
2454            }
2455    
2456            /**
2457            * Returns all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2458            *
2459            * @param groupId the group ID
2460            * @param status the status
2461            * @return the matching journal articles that the user has permission to view
2462            * @throws SystemException if a system exception occurred
2463            */
2464            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2465                    long groupId, int status)
2466                    throws com.liferay.portal.kernel.exception.SystemException {
2467                    return getPersistence().filterFindByG_ST(groupId, status);
2468            }
2469    
2470            /**
2471            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
2472            *
2473            * <p>
2474            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2475            * </p>
2476            *
2477            * @param groupId the group ID
2478            * @param status the status
2479            * @param start the lower bound of the range of journal articles
2480            * @param end the upper bound of the range of journal articles (not inclusive)
2481            * @return the range of matching journal articles that the user has permission to view
2482            * @throws SystemException if a system exception occurred
2483            */
2484            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2485                    long groupId, int status, int start, int end)
2486                    throws com.liferay.portal.kernel.exception.SystemException {
2487                    return getPersistence().filterFindByG_ST(groupId, status, start, end);
2488            }
2489    
2490            /**
2491            * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = &#63; and status = &#63;.
2492            *
2493            * <p>
2494            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2495            * </p>
2496            *
2497            * @param groupId the group ID
2498            * @param status the status
2499            * @param start the lower bound of the range of journal articles
2500            * @param end the upper bound of the range of journal articles (not inclusive)
2501            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2502            * @return the ordered range of matching journal articles that the user has permission to view
2503            * @throws SystemException if a system exception occurred
2504            */
2505            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST(
2506                    long groupId, int status, int start, int end,
2507                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2508                    throws com.liferay.portal.kernel.exception.SystemException {
2509                    return getPersistence()
2510                                       .filterFindByG_ST(groupId, status, start, end,
2511                            orderByComparator);
2512            }
2513    
2514            /**
2515            * 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;.
2516            *
2517            * @param id the primary key of the current journal article
2518            * @param groupId the group ID
2519            * @param status the status
2520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2521            * @return the previous, current, and next journal article
2522            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2523            * @throws SystemException if a system exception occurred
2524            */
2525            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext(
2526                    long id, long groupId, int status,
2527                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2528                    throws com.liferay.portal.kernel.exception.SystemException,
2529                            com.liferay.portlet.journal.NoSuchArticleException {
2530                    return getPersistence()
2531                                       .filterFindByG_ST_PrevAndNext(id, groupId, status,
2532                            orderByComparator);
2533            }
2534    
2535            /**
2536            * Returns all the journal articles where companyId = &#63; and version = &#63;.
2537            *
2538            * @param companyId the company ID
2539            * @param version the version
2540            * @return the matching journal articles
2541            * @throws SystemException if a system exception occurred
2542            */
2543            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2544                    long companyId, double version)
2545                    throws com.liferay.portal.kernel.exception.SystemException {
2546                    return getPersistence().findByC_V(companyId, version);
2547            }
2548    
2549            /**
2550            * Returns a range of all the journal articles where companyId = &#63; and version = &#63;.
2551            *
2552            * <p>
2553            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2554            * </p>
2555            *
2556            * @param companyId the company ID
2557            * @param version the version
2558            * @param start the lower bound of the range of journal articles
2559            * @param end the upper bound of the range of journal articles (not inclusive)
2560            * @return the range of matching journal articles
2561            * @throws SystemException if a system exception occurred
2562            */
2563            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2564                    long companyId, double version, int start, int end)
2565                    throws com.liferay.portal.kernel.exception.SystemException {
2566                    return getPersistence().findByC_V(companyId, version, start, end);
2567            }
2568    
2569            /**
2570            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63;.
2571            *
2572            * <p>
2573            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2574            * </p>
2575            *
2576            * @param companyId the company ID
2577            * @param version the version
2578            * @param start the lower bound of the range of journal articles
2579            * @param end the upper bound of the range of journal articles (not inclusive)
2580            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2581            * @return the ordered range of matching journal articles
2582            * @throws SystemException if a system exception occurred
2583            */
2584            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V(
2585                    long companyId, double version, int start, int end,
2586                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2587                    throws com.liferay.portal.kernel.exception.SystemException {
2588                    return getPersistence()
2589                                       .findByC_V(companyId, version, start, end, orderByComparator);
2590            }
2591    
2592            /**
2593            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63;.
2594            *
2595            * <p>
2596            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2597            * </p>
2598            *
2599            * @param companyId the company ID
2600            * @param version the version
2601            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2602            * @return the first matching journal article
2603            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2604            * @throws SystemException if a system exception occurred
2605            */
2606            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First(
2607                    long companyId, double version,
2608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2609                    throws com.liferay.portal.kernel.exception.SystemException,
2610                            com.liferay.portlet.journal.NoSuchArticleException {
2611                    return getPersistence()
2612                                       .findByC_V_First(companyId, version, orderByComparator);
2613            }
2614    
2615            /**
2616            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63;.
2617            *
2618            * <p>
2619            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2620            * </p>
2621            *
2622            * @param companyId the company ID
2623            * @param version the version
2624            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2625            * @return the last matching journal article
2626            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2627            * @throws SystemException if a system exception occurred
2628            */
2629            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last(
2630                    long companyId, double version,
2631                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2632                    throws com.liferay.portal.kernel.exception.SystemException,
2633                            com.liferay.portlet.journal.NoSuchArticleException {
2634                    return getPersistence()
2635                                       .findByC_V_Last(companyId, version, orderByComparator);
2636            }
2637    
2638            /**
2639            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63;.
2640            *
2641            * <p>
2642            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2643            * </p>
2644            *
2645            * @param id the primary key of the current journal article
2646            * @param companyId the company ID
2647            * @param version the version
2648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2649            * @return the previous, current, and next journal article
2650            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2651            * @throws SystemException if a system exception occurred
2652            */
2653            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext(
2654                    long id, long companyId, double version,
2655                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2656                    throws com.liferay.portal.kernel.exception.SystemException,
2657                            com.liferay.portlet.journal.NoSuchArticleException {
2658                    return getPersistence()
2659                                       .findByC_V_PrevAndNext(id, companyId, version,
2660                            orderByComparator);
2661            }
2662    
2663            /**
2664            * Returns all the journal articles where companyId = &#63; and status = &#63;.
2665            *
2666            * @param companyId the company ID
2667            * @param status the status
2668            * @return the matching journal articles
2669            * @throws SystemException if a system exception occurred
2670            */
2671            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2672                    long companyId, int status)
2673                    throws com.liferay.portal.kernel.exception.SystemException {
2674                    return getPersistence().findByC_ST(companyId, status);
2675            }
2676    
2677            /**
2678            * Returns a range of all the journal articles where companyId = &#63; and status = &#63;.
2679            *
2680            * <p>
2681            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2682            * </p>
2683            *
2684            * @param companyId the company ID
2685            * @param status the status
2686            * @param start the lower bound of the range of journal articles
2687            * @param end the upper bound of the range of journal articles (not inclusive)
2688            * @return the range of matching journal articles
2689            * @throws SystemException if a system exception occurred
2690            */
2691            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2692                    long companyId, int status, int start, int end)
2693                    throws com.liferay.portal.kernel.exception.SystemException {
2694                    return getPersistence().findByC_ST(companyId, status, start, end);
2695            }
2696    
2697            /**
2698            * Returns an ordered range of all the journal articles where companyId = &#63; and status = &#63;.
2699            *
2700            * <p>
2701            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2702            * </p>
2703            *
2704            * @param companyId the company ID
2705            * @param status the status
2706            * @param start the lower bound of the range of journal articles
2707            * @param end the upper bound of the range of journal articles (not inclusive)
2708            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2709            * @return the ordered range of matching journal articles
2710            * @throws SystemException if a system exception occurred
2711            */
2712            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST(
2713                    long companyId, int status, int start, int end,
2714                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2715                    throws com.liferay.portal.kernel.exception.SystemException {
2716                    return getPersistence()
2717                                       .findByC_ST(companyId, status, start, end, orderByComparator);
2718            }
2719    
2720            /**
2721            * Returns the first journal article in the ordered set where companyId = &#63; and status = &#63;.
2722            *
2723            * <p>
2724            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2725            * </p>
2726            *
2727            * @param companyId the company ID
2728            * @param status the status
2729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2730            * @return the first matching journal article
2731            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2732            * @throws SystemException if a system exception occurred
2733            */
2734            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First(
2735                    long companyId, int status,
2736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2737                    throws com.liferay.portal.kernel.exception.SystemException,
2738                            com.liferay.portlet.journal.NoSuchArticleException {
2739                    return getPersistence()
2740                                       .findByC_ST_First(companyId, status, orderByComparator);
2741            }
2742    
2743            /**
2744            * Returns the last journal article in the ordered set where companyId = &#63; and status = &#63;.
2745            *
2746            * <p>
2747            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2748            * </p>
2749            *
2750            * @param companyId the company ID
2751            * @param status the status
2752            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2753            * @return the last matching journal article
2754            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2755            * @throws SystemException if a system exception occurred
2756            */
2757            public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last(
2758                    long companyId, int status,
2759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2760                    throws com.liferay.portal.kernel.exception.SystemException,
2761                            com.liferay.portlet.journal.NoSuchArticleException {
2762                    return getPersistence()
2763                                       .findByC_ST_Last(companyId, status, orderByComparator);
2764            }
2765    
2766            /**
2767            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and status = &#63;.
2768            *
2769            * <p>
2770            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2771            * </p>
2772            *
2773            * @param id the primary key of the current journal article
2774            * @param companyId the company ID
2775            * @param status the status
2776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2777            * @return the previous, current, and next journal article
2778            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2779            * @throws SystemException if a system exception occurred
2780            */
2781            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext(
2782                    long id, long companyId, int status,
2783                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2784                    throws com.liferay.portal.kernel.exception.SystemException,
2785                            com.liferay.portlet.journal.NoSuchArticleException {
2786                    return getPersistence()
2787                                       .findByC_ST_PrevAndNext(id, companyId, status,
2788                            orderByComparator);
2789            }
2790    
2791            /**
2792            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2793            *
2794            * @param groupId the group ID
2795            * @param classNameId the class name ID
2796            * @param classPK the class p k
2797            * @return the matching journal articles
2798            * @throws SystemException if a system exception occurred
2799            */
2800            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2801                    long groupId, long classNameId, long classPK)
2802                    throws com.liferay.portal.kernel.exception.SystemException {
2803                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
2804            }
2805    
2806            /**
2807            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2808            *
2809            * <p>
2810            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2811            * </p>
2812            *
2813            * @param groupId the group ID
2814            * @param classNameId the class name ID
2815            * @param classPK the class p k
2816            * @param start the lower bound of the range of journal articles
2817            * @param end the upper bound of the range of journal articles (not inclusive)
2818            * @return the range of matching journal articles
2819            * @throws SystemException if a system exception occurred
2820            */
2821            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2822                    long groupId, long classNameId, long classPK, int start, int end)
2823                    throws com.liferay.portal.kernel.exception.SystemException {
2824                    return getPersistence()
2825                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
2826            }
2827    
2828            /**
2829            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2830            *
2831            * <p>
2832            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2833            * </p>
2834            *
2835            * @param groupId the group ID
2836            * @param classNameId the class name ID
2837            * @param classPK the class p k
2838            * @param start the lower bound of the range of journal articles
2839            * @param end the upper bound of the range of journal articles (not inclusive)
2840            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2841            * @return the ordered range of matching journal articles
2842            * @throws SystemException if a system exception occurred
2843            */
2844            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C(
2845                    long groupId, long classNameId, long classPK, int start, int end,
2846                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2847                    throws com.liferay.portal.kernel.exception.SystemException {
2848                    return getPersistence()
2849                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
2850                            orderByComparator);
2851            }
2852    
2853            /**
2854            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2855            *
2856            * <p>
2857            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2858            * </p>
2859            *
2860            * @param groupId the group ID
2861            * @param classNameId the class name ID
2862            * @param classPK the class p k
2863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2864            * @return the first matching journal article
2865            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2866            * @throws SystemException if a system exception occurred
2867            */
2868            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First(
2869                    long groupId, long classNameId, long classPK,
2870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2871                    throws com.liferay.portal.kernel.exception.SystemException,
2872                            com.liferay.portlet.journal.NoSuchArticleException {
2873                    return getPersistence()
2874                                       .findByG_C_C_First(groupId, classNameId, classPK,
2875                            orderByComparator);
2876            }
2877    
2878            /**
2879            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2880            *
2881            * <p>
2882            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2883            * </p>
2884            *
2885            * @param groupId the group ID
2886            * @param classNameId the class name ID
2887            * @param classPK the class p k
2888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2889            * @return the last matching journal article
2890            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
2891            * @throws SystemException if a system exception occurred
2892            */
2893            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last(
2894                    long groupId, long classNameId, long classPK,
2895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2896                    throws com.liferay.portal.kernel.exception.SystemException,
2897                            com.liferay.portlet.journal.NoSuchArticleException {
2898                    return getPersistence()
2899                                       .findByG_C_C_Last(groupId, classNameId, classPK,
2900                            orderByComparator);
2901            }
2902    
2903            /**
2904            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2905            *
2906            * <p>
2907            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2908            * </p>
2909            *
2910            * @param id the primary key of the current journal article
2911            * @param groupId the group ID
2912            * @param classNameId the class name ID
2913            * @param classPK the class p k
2914            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2915            * @return the previous, current, and next journal article
2916            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
2917            * @throws SystemException if a system exception occurred
2918            */
2919            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext(
2920                    long id, long groupId, long classNameId, long classPK,
2921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2922                    throws com.liferay.portal.kernel.exception.SystemException,
2923                            com.liferay.portlet.journal.NoSuchArticleException {
2924                    return getPersistence()
2925                                       .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK,
2926                            orderByComparator);
2927            }
2928    
2929            /**
2930            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2931            *
2932            * @param groupId the group ID
2933            * @param classNameId the class name ID
2934            * @param classPK the class p k
2935            * @return the matching journal articles that the user has permission to view
2936            * @throws SystemException if a system exception occurred
2937            */
2938            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2939                    long groupId, long classNameId, long classPK)
2940                    throws com.liferay.portal.kernel.exception.SystemException {
2941                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
2942            }
2943    
2944            /**
2945            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2946            *
2947            * <p>
2948            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2949            * </p>
2950            *
2951            * @param groupId the group ID
2952            * @param classNameId the class name ID
2953            * @param classPK the class p k
2954            * @param start the lower bound of the range of journal articles
2955            * @param end the upper bound of the range of journal articles (not inclusive)
2956            * @return the range of matching journal articles that the user has permission to view
2957            * @throws SystemException if a system exception occurred
2958            */
2959            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2960                    long groupId, long classNameId, long classPK, int start, int end)
2961                    throws com.liferay.portal.kernel.exception.SystemException {
2962                    return getPersistence()
2963                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
2964            }
2965    
2966            /**
2967            * 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;.
2968            *
2969            * <p>
2970            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2971            * </p>
2972            *
2973            * @param groupId the group ID
2974            * @param classNameId the class name ID
2975            * @param classPK the class p k
2976            * @param start the lower bound of the range of journal articles
2977            * @param end the upper bound of the range of journal articles (not inclusive)
2978            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2979            * @return the ordered range of matching journal articles that the user has permission to view
2980            * @throws SystemException if a system exception occurred
2981            */
2982            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C(
2983                    long groupId, long classNameId, long classPK, int start, int end,
2984                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2985                    throws com.liferay.portal.kernel.exception.SystemException {
2986                    return getPersistence()
2987                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
2988                            end, orderByComparator);
2989            }
2990    
2991            /**
2992            * 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;.
2993            *
2994            * @param id the primary key of the current journal article
2995            * @param groupId the group ID
2996            * @param classNameId the class name ID
2997            * @param classPK the class p k
2998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2999            * @return the previous, current, and next journal article
3000            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3001            * @throws SystemException if a system exception occurred
3002            */
3003            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext(
3004                    long id, long groupId, long classNameId, long classPK,
3005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3006                    throws com.liferay.portal.kernel.exception.SystemException,
3007                            com.liferay.portlet.journal.NoSuchArticleException {
3008                    return getPersistence()
3009                                       .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId,
3010                            classPK, orderByComparator);
3011            }
3012    
3013            /**
3014            * 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.
3015            *
3016            * @param groupId the group ID
3017            * @param classNameId the class name ID
3018            * @param structureId the structure ID
3019            * @return the matching journal article
3020            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3021            * @throws SystemException if a system exception occurred
3022            */
3023            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S(
3024                    long groupId, long classNameId, java.lang.String structureId)
3025                    throws com.liferay.portal.kernel.exception.SystemException,
3026                            com.liferay.portlet.journal.NoSuchArticleException {
3027                    return getPersistence().findByG_C_S(groupId, classNameId, structureId);
3028            }
3029    
3030            /**
3031            * 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.
3032            *
3033            * @param groupId the group ID
3034            * @param classNameId the class name ID
3035            * @param structureId the structure ID
3036            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3037            * @throws SystemException if a system exception occurred
3038            */
3039            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
3040                    long groupId, long classNameId, java.lang.String structureId)
3041                    throws com.liferay.portal.kernel.exception.SystemException {
3042                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureId);
3043            }
3044    
3045            /**
3046            * 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.
3047            *
3048            * @param groupId the group ID
3049            * @param classNameId the class name ID
3050            * @param structureId the structure ID
3051            * @param retrieveFromCache whether to use the finder cache
3052            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3053            * @throws SystemException if a system exception occurred
3054            */
3055            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S(
3056                    long groupId, long classNameId, java.lang.String structureId,
3057                    boolean retrieveFromCache)
3058                    throws com.liferay.portal.kernel.exception.SystemException {
3059                    return getPersistence()
3060                                       .fetchByG_C_S(groupId, classNameId, structureId,
3061                            retrieveFromCache);
3062            }
3063    
3064            /**
3065            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3066            *
3067            * @param groupId the group ID
3068            * @param classNameId the class name ID
3069            * @param templateId the template ID
3070            * @return the matching journal articles
3071            * @throws SystemException if a system exception occurred
3072            */
3073            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
3074                    long groupId, long classNameId, java.lang.String templateId)
3075                    throws com.liferay.portal.kernel.exception.SystemException {
3076                    return getPersistence().findByG_C_T(groupId, classNameId, templateId);
3077            }
3078    
3079            /**
3080            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3081            *
3082            * <p>
3083            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3084            * </p>
3085            *
3086            * @param groupId the group ID
3087            * @param classNameId the class name ID
3088            * @param templateId the template ID
3089            * @param start the lower bound of the range of journal articles
3090            * @param end the upper bound of the range of journal articles (not inclusive)
3091            * @return the range of matching journal articles
3092            * @throws SystemException if a system exception occurred
3093            */
3094            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
3095                    long groupId, long classNameId, java.lang.String templateId, int start,
3096                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3097                    return getPersistence()
3098                                       .findByG_C_T(groupId, classNameId, templateId, start, end);
3099            }
3100    
3101            /**
3102            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3103            *
3104            * <p>
3105            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3106            * </p>
3107            *
3108            * @param groupId the group ID
3109            * @param classNameId the class name ID
3110            * @param templateId the template ID
3111            * @param start the lower bound of the range of journal articles
3112            * @param end the upper bound of the range of journal articles (not inclusive)
3113            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3114            * @return the ordered range of matching journal articles
3115            * @throws SystemException if a system exception occurred
3116            */
3117            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T(
3118                    long groupId, long classNameId, java.lang.String templateId, int start,
3119                    int end,
3120                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3121                    throws com.liferay.portal.kernel.exception.SystemException {
3122                    return getPersistence()
3123                                       .findByG_C_T(groupId, classNameId, templateId, start, end,
3124                            orderByComparator);
3125            }
3126    
3127            /**
3128            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3129            *
3130            * <p>
3131            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3132            * </p>
3133            *
3134            * @param groupId the group ID
3135            * @param classNameId the class name ID
3136            * @param templateId the template ID
3137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3138            * @return the first matching journal article
3139            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3140            * @throws SystemException if a system exception occurred
3141            */
3142            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First(
3143                    long groupId, long classNameId, java.lang.String templateId,
3144                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3145                    throws com.liferay.portal.kernel.exception.SystemException,
3146                            com.liferay.portlet.journal.NoSuchArticleException {
3147                    return getPersistence()
3148                                       .findByG_C_T_First(groupId, classNameId, templateId,
3149                            orderByComparator);
3150            }
3151    
3152            /**
3153            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3154            *
3155            * <p>
3156            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3157            * </p>
3158            *
3159            * @param groupId the group ID
3160            * @param classNameId the class name ID
3161            * @param templateId the template ID
3162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3163            * @return the last matching journal article
3164            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3165            * @throws SystemException if a system exception occurred
3166            */
3167            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last(
3168                    long groupId, long classNameId, java.lang.String templateId,
3169                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3170                    throws com.liferay.portal.kernel.exception.SystemException,
3171                            com.liferay.portlet.journal.NoSuchArticleException {
3172                    return getPersistence()
3173                                       .findByG_C_T_Last(groupId, classNameId, templateId,
3174                            orderByComparator);
3175            }
3176    
3177            /**
3178            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3179            *
3180            * <p>
3181            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3182            * </p>
3183            *
3184            * @param id the primary key of the current journal article
3185            * @param groupId the group ID
3186            * @param classNameId the class name ID
3187            * @param templateId the template ID
3188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3189            * @return the previous, current, and next journal article
3190            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3191            * @throws SystemException if a system exception occurred
3192            */
3193            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext(
3194                    long id, long groupId, long classNameId, java.lang.String templateId,
3195                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3196                    throws com.liferay.portal.kernel.exception.SystemException,
3197                            com.liferay.portlet.journal.NoSuchArticleException {
3198                    return getPersistence()
3199                                       .findByG_C_T_PrevAndNext(id, groupId, classNameId,
3200                            templateId, orderByComparator);
3201            }
3202    
3203            /**
3204            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3205            *
3206            * @param groupId the group ID
3207            * @param classNameId the class name ID
3208            * @param templateId the template ID
3209            * @return the matching journal articles that the user has permission to view
3210            * @throws SystemException if a system exception occurred
3211            */
3212            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3213                    long groupId, long classNameId, java.lang.String templateId)
3214                    throws com.liferay.portal.kernel.exception.SystemException {
3215                    return getPersistence()
3216                                       .filterFindByG_C_T(groupId, classNameId, templateId);
3217            }
3218    
3219            /**
3220            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
3221            *
3222            * <p>
3223            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3224            * </p>
3225            *
3226            * @param groupId the group ID
3227            * @param classNameId the class name ID
3228            * @param templateId the template ID
3229            * @param start the lower bound of the range of journal articles
3230            * @param end the upper bound of the range of journal articles (not inclusive)
3231            * @return the range of matching journal articles that the user has permission to view
3232            * @throws SystemException if a system exception occurred
3233            */
3234            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3235                    long groupId, long classNameId, java.lang.String templateId, int start,
3236                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3237                    return getPersistence()
3238                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3239                            end);
3240            }
3241    
3242            /**
3243            * 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;.
3244            *
3245            * <p>
3246            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3247            * </p>
3248            *
3249            * @param groupId the group ID
3250            * @param classNameId the class name ID
3251            * @param templateId the template ID
3252            * @param start the lower bound of the range of journal articles
3253            * @param end the upper bound of the range of journal articles (not inclusive)
3254            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3255            * @return the ordered range of matching journal articles that the user has permission to view
3256            * @throws SystemException if a system exception occurred
3257            */
3258            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T(
3259                    long groupId, long classNameId, java.lang.String templateId, int start,
3260                    int end,
3261                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3262                    throws com.liferay.portal.kernel.exception.SystemException {
3263                    return getPersistence()
3264                                       .filterFindByG_C_T(groupId, classNameId, templateId, start,
3265                            end, orderByComparator);
3266            }
3267    
3268            /**
3269            * 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;.
3270            *
3271            * @param id the primary key of the current journal article
3272            * @param groupId the group ID
3273            * @param classNameId the class name ID
3274            * @param templateId the template ID
3275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3276            * @return the previous, current, and next journal article
3277            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3278            * @throws SystemException if a system exception occurred
3279            */
3280            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext(
3281                    long id, long groupId, long classNameId, java.lang.String templateId,
3282                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3283                    throws com.liferay.portal.kernel.exception.SystemException,
3284                            com.liferay.portlet.journal.NoSuchArticleException {
3285                    return getPersistence()
3286                                       .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId,
3287                            templateId, orderByComparator);
3288            }
3289    
3290            /**
3291            * Returns all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3292            *
3293            * @param groupId the group ID
3294            * @param classNameId the class name ID
3295            * @param layoutUuid the layout uuid
3296            * @return the matching journal articles
3297            * @throws SystemException if a system exception occurred
3298            */
3299            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3300                    long groupId, long classNameId, java.lang.String layoutUuid)
3301                    throws com.liferay.portal.kernel.exception.SystemException {
3302                    return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid);
3303            }
3304    
3305            /**
3306            * Returns a range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3307            *
3308            * <p>
3309            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3310            * </p>
3311            *
3312            * @param groupId the group ID
3313            * @param classNameId the class name ID
3314            * @param layoutUuid the layout uuid
3315            * @param start the lower bound of the range of journal articles
3316            * @param end the upper bound of the range of journal articles (not inclusive)
3317            * @return the range of matching journal articles
3318            * @throws SystemException if a system exception occurred
3319            */
3320            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3321                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3322                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3323                    return getPersistence()
3324                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end);
3325            }
3326    
3327            /**
3328            * Returns an ordered range of all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3329            *
3330            * <p>
3331            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3332            * </p>
3333            *
3334            * @param groupId the group ID
3335            * @param classNameId the class name ID
3336            * @param layoutUuid the layout uuid
3337            * @param start the lower bound of the range of journal articles
3338            * @param end the upper bound of the range of journal articles (not inclusive)
3339            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3340            * @return the ordered range of matching journal articles
3341            * @throws SystemException if a system exception occurred
3342            */
3343            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L(
3344                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3345                    int end,
3346                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3347                    throws com.liferay.portal.kernel.exception.SystemException {
3348                    return getPersistence()
3349                                       .findByG_C_L(groupId, classNameId, layoutUuid, start, end,
3350                            orderByComparator);
3351            }
3352    
3353            /**
3354            * Returns the first journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3355            *
3356            * <p>
3357            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3358            * </p>
3359            *
3360            * @param groupId the group ID
3361            * @param classNameId the class name ID
3362            * @param layoutUuid the layout uuid
3363            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3364            * @return the first matching journal article
3365            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3366            * @throws SystemException if a system exception occurred
3367            */
3368            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First(
3369                    long groupId, long classNameId, java.lang.String layoutUuid,
3370                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3371                    throws com.liferay.portal.kernel.exception.SystemException,
3372                            com.liferay.portlet.journal.NoSuchArticleException {
3373                    return getPersistence()
3374                                       .findByG_C_L_First(groupId, classNameId, layoutUuid,
3375                            orderByComparator);
3376            }
3377    
3378            /**
3379            * Returns the last journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3380            *
3381            * <p>
3382            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3383            * </p>
3384            *
3385            * @param groupId the group ID
3386            * @param classNameId the class name ID
3387            * @param layoutUuid the layout uuid
3388            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3389            * @return the last matching journal article
3390            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3391            * @throws SystemException if a system exception occurred
3392            */
3393            public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last(
3394                    long groupId, long classNameId, java.lang.String layoutUuid,
3395                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3396                    throws com.liferay.portal.kernel.exception.SystemException,
3397                            com.liferay.portlet.journal.NoSuchArticleException {
3398                    return getPersistence()
3399                                       .findByG_C_L_Last(groupId, classNameId, layoutUuid,
3400                            orderByComparator);
3401            }
3402    
3403            /**
3404            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3405            *
3406            * <p>
3407            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3408            * </p>
3409            *
3410            * @param id the primary key of the current journal article
3411            * @param groupId the group ID
3412            * @param classNameId the class name ID
3413            * @param layoutUuid the layout uuid
3414            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3415            * @return the previous, current, and next journal article
3416            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3417            * @throws SystemException if a system exception occurred
3418            */
3419            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext(
3420                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3421                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3422                    throws com.liferay.portal.kernel.exception.SystemException,
3423                            com.liferay.portlet.journal.NoSuchArticleException {
3424                    return getPersistence()
3425                                       .findByG_C_L_PrevAndNext(id, groupId, classNameId,
3426                            layoutUuid, orderByComparator);
3427            }
3428    
3429            /**
3430            * Returns all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3431            *
3432            * @param groupId the group ID
3433            * @param classNameId the class name ID
3434            * @param layoutUuid the layout uuid
3435            * @return the matching journal articles that the user has permission to view
3436            * @throws SystemException if a system exception occurred
3437            */
3438            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3439                    long groupId, long classNameId, java.lang.String layoutUuid)
3440                    throws com.liferay.portal.kernel.exception.SystemException {
3441                    return getPersistence()
3442                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid);
3443            }
3444    
3445            /**
3446            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
3447            *
3448            * <p>
3449            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3450            * </p>
3451            *
3452            * @param groupId the group ID
3453            * @param classNameId the class name ID
3454            * @param layoutUuid the layout uuid
3455            * @param start the lower bound of the range of journal articles
3456            * @param end the upper bound of the range of journal articles (not inclusive)
3457            * @return the range of matching journal articles that the user has permission to view
3458            * @throws SystemException if a system exception occurred
3459            */
3460            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3461                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3462                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3463                    return getPersistence()
3464                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3465                            end);
3466            }
3467    
3468            /**
3469            * 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;.
3470            *
3471            * <p>
3472            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3473            * </p>
3474            *
3475            * @param groupId the group ID
3476            * @param classNameId the class name ID
3477            * @param layoutUuid the layout uuid
3478            * @param start the lower bound of the range of journal articles
3479            * @param end the upper bound of the range of journal articles (not inclusive)
3480            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3481            * @return the ordered range of matching journal articles that the user has permission to view
3482            * @throws SystemException if a system exception occurred
3483            */
3484            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L(
3485                    long groupId, long classNameId, java.lang.String layoutUuid, int start,
3486                    int end,
3487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3488                    throws com.liferay.portal.kernel.exception.SystemException {
3489                    return getPersistence()
3490                                       .filterFindByG_C_L(groupId, classNameId, layoutUuid, start,
3491                            end, orderByComparator);
3492            }
3493    
3494            /**
3495            * 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;.
3496            *
3497            * @param id the primary key of the current journal article
3498            * @param groupId the group ID
3499            * @param classNameId the class name ID
3500            * @param layoutUuid the layout uuid
3501            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3502            * @return the previous, current, and next journal article
3503            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3504            * @throws SystemException if a system exception occurred
3505            */
3506            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext(
3507                    long id, long groupId, long classNameId, java.lang.String layoutUuid,
3508                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3509                    throws com.liferay.portal.kernel.exception.SystemException,
3510                            com.liferay.portlet.journal.NoSuchArticleException {
3511                    return getPersistence()
3512                                       .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId,
3513                            layoutUuid, orderByComparator);
3514            }
3515    
3516            /**
3517            * 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.
3518            *
3519            * @param groupId the group ID
3520            * @param articleId the article ID
3521            * @param version the version
3522            * @return the matching journal article
3523            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3524            * @throws SystemException if a system exception occurred
3525            */
3526            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V(
3527                    long groupId, java.lang.String articleId, double version)
3528                    throws com.liferay.portal.kernel.exception.SystemException,
3529                            com.liferay.portlet.journal.NoSuchArticleException {
3530                    return getPersistence().findByG_A_V(groupId, articleId, version);
3531            }
3532    
3533            /**
3534            * 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.
3535            *
3536            * @param groupId the group ID
3537            * @param articleId the article ID
3538            * @param version the version
3539            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3540            * @throws SystemException if a system exception occurred
3541            */
3542            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3543                    long groupId, java.lang.String articleId, double version)
3544                    throws com.liferay.portal.kernel.exception.SystemException {
3545                    return getPersistence().fetchByG_A_V(groupId, articleId, version);
3546            }
3547    
3548            /**
3549            * 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.
3550            *
3551            * @param groupId the group ID
3552            * @param articleId the article ID
3553            * @param version the version
3554            * @param retrieveFromCache whether to use the finder cache
3555            * @return the matching journal article, or <code>null</code> if a matching journal article could not be found
3556            * @throws SystemException if a system exception occurred
3557            */
3558            public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V(
3559                    long groupId, java.lang.String articleId, double version,
3560                    boolean retrieveFromCache)
3561                    throws com.liferay.portal.kernel.exception.SystemException {
3562                    return getPersistence()
3563                                       .fetchByG_A_V(groupId, articleId, version, retrieveFromCache);
3564            }
3565    
3566            /**
3567            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3568            *
3569            * @param groupId the group ID
3570            * @param articleId the article ID
3571            * @param status the status
3572            * @return the matching journal articles
3573            * @throws SystemException if a system exception occurred
3574            */
3575            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3576                    long groupId, java.lang.String articleId, int status)
3577                    throws com.liferay.portal.kernel.exception.SystemException {
3578                    return getPersistence().findByG_A_ST(groupId, articleId, status);
3579            }
3580    
3581            /**
3582            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3583            *
3584            * <p>
3585            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3586            * </p>
3587            *
3588            * @param groupId the group ID
3589            * @param articleId the article ID
3590            * @param status the status
3591            * @param start the lower bound of the range of journal articles
3592            * @param end the upper bound of the range of journal articles (not inclusive)
3593            * @return the range of matching journal articles
3594            * @throws SystemException if a system exception occurred
3595            */
3596            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3597                    long groupId, java.lang.String articleId, int status, int start, int end)
3598                    throws com.liferay.portal.kernel.exception.SystemException {
3599                    return getPersistence()
3600                                       .findByG_A_ST(groupId, articleId, status, start, end);
3601            }
3602    
3603            /**
3604            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
3605            *
3606            * <p>
3607            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3608            * </p>
3609            *
3610            * @param groupId the group ID
3611            * @param articleId the article ID
3612            * @param status the status
3613            * @param start the lower bound of the range of journal articles
3614            * @param end the upper bound of the range of journal articles (not inclusive)
3615            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3616            * @return the ordered range of matching journal articles
3617            * @throws SystemException if a system exception occurred
3618            */
3619            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3620                    long groupId, java.lang.String articleId, int status, int start,
3621                    int end,
3622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3623                    throws com.liferay.portal.kernel.exception.SystemException {
3624                    return getPersistence()
3625                                       .findByG_A_ST(groupId, articleId, status, start, end,
3626                            orderByComparator);
3627            }
3628    
3629            /**
3630            * Returns the first journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3631            *
3632            * <p>
3633            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3634            * </p>
3635            *
3636            * @param groupId the group ID
3637            * @param articleId the article ID
3638            * @param status the status
3639            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3640            * @return the first matching journal article
3641            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3642            * @throws SystemException if a system exception occurred
3643            */
3644            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First(
3645                    long groupId, java.lang.String articleId, int status,
3646                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3647                    throws com.liferay.portal.kernel.exception.SystemException,
3648                            com.liferay.portlet.journal.NoSuchArticleException {
3649                    return getPersistence()
3650                                       .findByG_A_ST_First(groupId, articleId, status,
3651                            orderByComparator);
3652            }
3653    
3654            /**
3655            * Returns the last journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3656            *
3657            * <p>
3658            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3659            * </p>
3660            *
3661            * @param groupId the group ID
3662            * @param articleId the article ID
3663            * @param status the status
3664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3665            * @return the last matching journal article
3666            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3667            * @throws SystemException if a system exception occurred
3668            */
3669            public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last(
3670                    long groupId, java.lang.String articleId, int status,
3671                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3672                    throws com.liferay.portal.kernel.exception.SystemException,
3673                            com.liferay.portlet.journal.NoSuchArticleException {
3674                    return getPersistence()
3675                                       .findByG_A_ST_Last(groupId, articleId, status,
3676                            orderByComparator);
3677            }
3678    
3679            /**
3680            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and articleId = &#63; and status = &#63;.
3681            *
3682            * <p>
3683            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3684            * </p>
3685            *
3686            * @param id the primary key of the current journal article
3687            * @param groupId the group ID
3688            * @param articleId the article ID
3689            * @param status the status
3690            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3691            * @return the previous, current, and next journal article
3692            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3693            * @throws SystemException if a system exception occurred
3694            */
3695            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext(
3696                    long id, long groupId, java.lang.String articleId, int status,
3697                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3698                    throws com.liferay.portal.kernel.exception.SystemException,
3699                            com.liferay.portlet.journal.NoSuchArticleException {
3700                    return getPersistence()
3701                                       .findByG_A_ST_PrevAndNext(id, groupId, articleId, status,
3702                            orderByComparator);
3703            }
3704    
3705            /**
3706            * Returns all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
3707            *
3708            * <p>
3709            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3710            * </p>
3711            *
3712            * @param groupId the group ID
3713            * @param articleId the article ID
3714            * @param statuses the statuses
3715            * @return the matching journal articles
3716            * @throws SystemException if a system exception occurred
3717            */
3718            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3719                    long groupId, java.lang.String articleId, int[] statuses)
3720                    throws com.liferay.portal.kernel.exception.SystemException {
3721                    return getPersistence().findByG_A_ST(groupId, articleId, statuses);
3722            }
3723    
3724            /**
3725            * Returns a range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
3726            *
3727            * <p>
3728            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3729            * </p>
3730            *
3731            * @param groupId the group ID
3732            * @param articleId the article ID
3733            * @param statuses the statuses
3734            * @param start the lower bound of the range of journal articles
3735            * @param end the upper bound of the range of journal articles (not inclusive)
3736            * @return the range of matching journal articles
3737            * @throws SystemException if a system exception occurred
3738            */
3739            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3740                    long groupId, java.lang.String articleId, int[] statuses, int start,
3741                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3742                    return getPersistence()
3743                                       .findByG_A_ST(groupId, articleId, statuses, start, end);
3744            }
3745    
3746            /**
3747            * Returns an ordered range of all the journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
3748            *
3749            * <p>
3750            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3751            * </p>
3752            *
3753            * @param groupId the group ID
3754            * @param articleId the article ID
3755            * @param statuses the statuses
3756            * @param start the lower bound of the range of journal articles
3757            * @param end the upper bound of the range of journal articles (not inclusive)
3758            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3759            * @return the ordered range of matching journal articles
3760            * @throws SystemException if a system exception occurred
3761            */
3762            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST(
3763                    long groupId, java.lang.String articleId, int[] statuses, int start,
3764                    int end,
3765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3766                    throws com.liferay.portal.kernel.exception.SystemException {
3767                    return getPersistence()
3768                                       .findByG_A_ST(groupId, articleId, statuses, start, end,
3769                            orderByComparator);
3770            }
3771    
3772            /**
3773            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3774            *
3775            * @param groupId the group ID
3776            * @param articleId the article ID
3777            * @param status the status
3778            * @return the matching journal articles that the user has permission to view
3779            * @throws SystemException if a system exception occurred
3780            */
3781            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3782                    long groupId, java.lang.String articleId, int status)
3783                    throws com.liferay.portal.kernel.exception.SystemException {
3784                    return getPersistence().filterFindByG_A_ST(groupId, articleId, status);
3785            }
3786    
3787            /**
3788            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
3789            *
3790            * <p>
3791            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3792            * </p>
3793            *
3794            * @param groupId the group ID
3795            * @param articleId the article ID
3796            * @param status the status
3797            * @param start the lower bound of the range of journal articles
3798            * @param end the upper bound of the range of journal articles (not inclusive)
3799            * @return the range of matching journal articles that the user has permission to view
3800            * @throws SystemException if a system exception occurred
3801            */
3802            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3803                    long groupId, java.lang.String articleId, int status, int start, int end)
3804                    throws com.liferay.portal.kernel.exception.SystemException {
3805                    return getPersistence()
3806                                       .filterFindByG_A_ST(groupId, articleId, status, start, end);
3807            }
3808    
3809            /**
3810            * 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;.
3811            *
3812            * <p>
3813            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3814            * </p>
3815            *
3816            * @param groupId the group ID
3817            * @param articleId the article ID
3818            * @param status the status
3819            * @param start the lower bound of the range of journal articles
3820            * @param end the upper bound of the range of journal articles (not inclusive)
3821            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3822            * @return the ordered range of matching journal articles that the user has permission to view
3823            * @throws SystemException if a system exception occurred
3824            */
3825            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3826                    long groupId, java.lang.String articleId, int status, int start,
3827                    int end,
3828                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3829                    throws com.liferay.portal.kernel.exception.SystemException {
3830                    return getPersistence()
3831                                       .filterFindByG_A_ST(groupId, articleId, status, start, end,
3832                            orderByComparator);
3833            }
3834    
3835            /**
3836            * 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;.
3837            *
3838            * @param id the primary key of the current journal article
3839            * @param groupId the group ID
3840            * @param articleId the article ID
3841            * @param status the status
3842            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3843            * @return the previous, current, and next journal article
3844            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
3845            * @throws SystemException if a system exception occurred
3846            */
3847            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext(
3848                    long id, long groupId, java.lang.String articleId, int status,
3849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3850                    throws com.liferay.portal.kernel.exception.SystemException,
3851                            com.liferay.portlet.journal.NoSuchArticleException {
3852                    return getPersistence()
3853                                       .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId,
3854                            status, orderByComparator);
3855            }
3856    
3857            /**
3858            * Returns all the journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
3859            *
3860            * @param groupId the group ID
3861            * @param articleId the article ID
3862            * @param statuses the statuses
3863            * @return the matching journal articles that the user has permission to view
3864            * @throws SystemException if a system exception occurred
3865            */
3866            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3867                    long groupId, java.lang.String articleId, int[] statuses)
3868                    throws com.liferay.portal.kernel.exception.SystemException {
3869                    return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses);
3870            }
3871    
3872            /**
3873            * 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;.
3874            *
3875            * <p>
3876            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3877            * </p>
3878            *
3879            * @param groupId the group ID
3880            * @param articleId the article ID
3881            * @param statuses the statuses
3882            * @param start the lower bound of the range of journal articles
3883            * @param end the upper bound of the range of journal articles (not inclusive)
3884            * @return the range of matching journal articles that the user has permission to view
3885            * @throws SystemException if a system exception occurred
3886            */
3887            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3888                    long groupId, java.lang.String articleId, int[] statuses, int start,
3889                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3890                    return getPersistence()
3891                                       .filterFindByG_A_ST(groupId, articleId, statuses, start, end);
3892            }
3893    
3894            /**
3895            * 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;.
3896            *
3897            * <p>
3898            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3899            * </p>
3900            *
3901            * @param groupId the group ID
3902            * @param articleId the article ID
3903            * @param statuses the statuses
3904            * @param start the lower bound of the range of journal articles
3905            * @param end the upper bound of the range of journal articles (not inclusive)
3906            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3907            * @return the ordered range of matching journal articles that the user has permission to view
3908            * @throws SystemException if a system exception occurred
3909            */
3910            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST(
3911                    long groupId, java.lang.String articleId, int[] statuses, int start,
3912                    int end,
3913                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3914                    throws com.liferay.portal.kernel.exception.SystemException {
3915                    return getPersistence()
3916                                       .filterFindByG_A_ST(groupId, articleId, statuses, start,
3917                            end, orderByComparator);
3918            }
3919    
3920            /**
3921            * Returns all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3922            *
3923            * @param groupId the group ID
3924            * @param urlTitle the url title
3925            * @param status the status
3926            * @return the matching journal articles
3927            * @throws SystemException if a system exception occurred
3928            */
3929            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3930                    long groupId, java.lang.String urlTitle, int status)
3931                    throws com.liferay.portal.kernel.exception.SystemException {
3932                    return getPersistence().findByG_UT_ST(groupId, urlTitle, status);
3933            }
3934    
3935            /**
3936            * Returns a range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3937            *
3938            * <p>
3939            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3940            * </p>
3941            *
3942            * @param groupId the group ID
3943            * @param urlTitle the url title
3944            * @param status the status
3945            * @param start the lower bound of the range of journal articles
3946            * @param end the upper bound of the range of journal articles (not inclusive)
3947            * @return the range of matching journal articles
3948            * @throws SystemException if a system exception occurred
3949            */
3950            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3951                    long groupId, java.lang.String urlTitle, int status, int start, int end)
3952                    throws com.liferay.portal.kernel.exception.SystemException {
3953                    return getPersistence()
3954                                       .findByG_UT_ST(groupId, urlTitle, status, start, end);
3955            }
3956    
3957            /**
3958            * Returns an ordered range of all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3959            *
3960            * <p>
3961            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3962            * </p>
3963            *
3964            * @param groupId the group ID
3965            * @param urlTitle the url title
3966            * @param status the status
3967            * @param start the lower bound of the range of journal articles
3968            * @param end the upper bound of the range of journal articles (not inclusive)
3969            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3970            * @return the ordered range of matching journal articles
3971            * @throws SystemException if a system exception occurred
3972            */
3973            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST(
3974                    long groupId, java.lang.String urlTitle, int status, int start,
3975                    int end,
3976                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3977                    throws com.liferay.portal.kernel.exception.SystemException {
3978                    return getPersistence()
3979                                       .findByG_UT_ST(groupId, urlTitle, status, start, end,
3980                            orderByComparator);
3981            }
3982    
3983            /**
3984            * Returns the first journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
3985            *
3986            * <p>
3987            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3988            * </p>
3989            *
3990            * @param groupId the group ID
3991            * @param urlTitle the url title
3992            * @param status the status
3993            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3994            * @return the first matching journal article
3995            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
3996            * @throws SystemException if a system exception occurred
3997            */
3998            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First(
3999                    long groupId, java.lang.String urlTitle, int status,
4000                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4001                    throws com.liferay.portal.kernel.exception.SystemException,
4002                            com.liferay.portlet.journal.NoSuchArticleException {
4003                    return getPersistence()
4004                                       .findByG_UT_ST_First(groupId, urlTitle, status,
4005                            orderByComparator);
4006            }
4007    
4008            /**
4009            * Returns the last journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4010            *
4011            * <p>
4012            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4013            * </p>
4014            *
4015            * @param groupId the group ID
4016            * @param urlTitle the url title
4017            * @param status the status
4018            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4019            * @return the last matching journal article
4020            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4021            * @throws SystemException if a system exception occurred
4022            */
4023            public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last(
4024                    long groupId, java.lang.String urlTitle, int status,
4025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4026                    throws com.liferay.portal.kernel.exception.SystemException,
4027                            com.liferay.portlet.journal.NoSuchArticleException {
4028                    return getPersistence()
4029                                       .findByG_UT_ST_Last(groupId, urlTitle, status,
4030                            orderByComparator);
4031            }
4032    
4033            /**
4034            * Returns the journal articles before and after the current journal article in the ordered set where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4035            *
4036            * <p>
4037            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4038            * </p>
4039            *
4040            * @param id the primary key of the current journal article
4041            * @param groupId the group ID
4042            * @param urlTitle the url title
4043            * @param status the status
4044            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4045            * @return the previous, current, and next journal article
4046            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4047            * @throws SystemException if a system exception occurred
4048            */
4049            public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext(
4050                    long id, long groupId, java.lang.String urlTitle, int status,
4051                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4052                    throws com.liferay.portal.kernel.exception.SystemException,
4053                            com.liferay.portlet.journal.NoSuchArticleException {
4054                    return getPersistence()
4055                                       .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status,
4056                            orderByComparator);
4057            }
4058    
4059            /**
4060            * Returns all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4061            *
4062            * @param groupId the group ID
4063            * @param urlTitle the url title
4064            * @param status the status
4065            * @return the matching journal articles that the user has permission to view
4066            * @throws SystemException if a system exception occurred
4067            */
4068            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
4069                    long groupId, java.lang.String urlTitle, int status)
4070                    throws com.liferay.portal.kernel.exception.SystemException {
4071                    return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status);
4072            }
4073    
4074            /**
4075            * Returns a range of all the journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
4076            *
4077            * <p>
4078            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4079            * </p>
4080            *
4081            * @param groupId the group ID
4082            * @param urlTitle the url title
4083            * @param status the status
4084            * @param start the lower bound of the range of journal articles
4085            * @param end the upper bound of the range of journal articles (not inclusive)
4086            * @return the range of matching journal articles that the user has permission to view
4087            * @throws SystemException if a system exception occurred
4088            */
4089            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
4090                    long groupId, java.lang.String urlTitle, int status, int start, int end)
4091                    throws com.liferay.portal.kernel.exception.SystemException {
4092                    return getPersistence()
4093                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end);
4094            }
4095    
4096            /**
4097            * 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;.
4098            *
4099            * <p>
4100            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4101            * </p>
4102            *
4103            * @param groupId the group ID
4104            * @param urlTitle the url title
4105            * @param status the status
4106            * @param start the lower bound of the range of journal articles
4107            * @param end the upper bound of the range of journal articles (not inclusive)
4108            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4109            * @return the ordered range of matching journal articles that the user has permission to view
4110            * @throws SystemException if a system exception occurred
4111            */
4112            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST(
4113                    long groupId, java.lang.String urlTitle, int status, int start,
4114                    int end,
4115                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4116                    throws com.liferay.portal.kernel.exception.SystemException {
4117                    return getPersistence()
4118                                       .filterFindByG_UT_ST(groupId, urlTitle, status, start, end,
4119                            orderByComparator);
4120            }
4121    
4122            /**
4123            * 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;.
4124            *
4125            * @param id the primary key of the current journal article
4126            * @param groupId the group ID
4127            * @param urlTitle the url title
4128            * @param status the status
4129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4130            * @return the previous, current, and next journal article
4131            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4132            * @throws SystemException if a system exception occurred
4133            */
4134            public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext(
4135                    long id, long groupId, java.lang.String urlTitle, int status,
4136                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4137                    throws com.liferay.portal.kernel.exception.SystemException,
4138                            com.liferay.portlet.journal.NoSuchArticleException {
4139                    return getPersistence()
4140                                       .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle,
4141                            status, orderByComparator);
4142            }
4143    
4144            /**
4145            * Returns all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4146            *
4147            * @param companyId the company ID
4148            * @param version the version
4149            * @param status the status
4150            * @return the matching journal articles
4151            * @throws SystemException if a system exception occurred
4152            */
4153            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
4154                    long companyId, double version, int status)
4155                    throws com.liferay.portal.kernel.exception.SystemException {
4156                    return getPersistence().findByC_V_ST(companyId, version, status);
4157            }
4158    
4159            /**
4160            * Returns a range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4161            *
4162            * <p>
4163            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4164            * </p>
4165            *
4166            * @param companyId the company ID
4167            * @param version the version
4168            * @param status the status
4169            * @param start the lower bound of the range of journal articles
4170            * @param end the upper bound of the range of journal articles (not inclusive)
4171            * @return the range of matching journal articles
4172            * @throws SystemException if a system exception occurred
4173            */
4174            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
4175                    long companyId, double version, int status, int start, int end)
4176                    throws com.liferay.portal.kernel.exception.SystemException {
4177                    return getPersistence()
4178                                       .findByC_V_ST(companyId, version, status, start, end);
4179            }
4180    
4181            /**
4182            * Returns an ordered range of all the journal articles where companyId = &#63; and version = &#63; and status = &#63;.
4183            *
4184            * <p>
4185            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4186            * </p>
4187            *
4188            * @param companyId the company ID
4189            * @param version the version
4190            * @param status the status
4191            * @param start the lower bound of the range of journal articles
4192            * @param end the upper bound of the range of journal articles (not inclusive)
4193            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4194            * @return the ordered range of matching journal articles
4195            * @throws SystemException if a system exception occurred
4196            */
4197            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST(
4198                    long companyId, double version, int status, int start, int end,
4199                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4200                    throws com.liferay.portal.kernel.exception.SystemException {
4201                    return getPersistence()
4202                                       .findByC_V_ST(companyId, version, status, start, end,
4203                            orderByComparator);
4204            }
4205    
4206            /**
4207            * Returns the first journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4208            *
4209            * <p>
4210            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4211            * </p>
4212            *
4213            * @param companyId the company ID
4214            * @param version the version
4215            * @param status the status
4216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4217            * @return the first matching journal article
4218            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4219            * @throws SystemException if a system exception occurred
4220            */
4221            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First(
4222                    long companyId, double version, int status,
4223                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4224                    throws com.liferay.portal.kernel.exception.SystemException,
4225                            com.liferay.portlet.journal.NoSuchArticleException {
4226                    return getPersistence()
4227                                       .findByC_V_ST_First(companyId, version, status,
4228                            orderByComparator);
4229            }
4230    
4231            /**
4232            * Returns the last journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4233            *
4234            * <p>
4235            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4236            * </p>
4237            *
4238            * @param companyId the company ID
4239            * @param version the version
4240            * @param status the status
4241            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4242            * @return the last matching journal article
4243            * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found
4244            * @throws SystemException if a system exception occurred
4245            */
4246            public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last(
4247                    long companyId, double version, int status,
4248                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4249                    throws com.liferay.portal.kernel.exception.SystemException,
4250                            com.liferay.portlet.journal.NoSuchArticleException {
4251                    return getPersistence()
4252                                       .findByC_V_ST_Last(companyId, version, status,
4253                            orderByComparator);
4254            }
4255    
4256            /**
4257            * Returns the journal articles before and after the current journal article in the ordered set where companyId = &#63; and version = &#63; and status = &#63;.
4258            *
4259            * <p>
4260            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4261            * </p>
4262            *
4263            * @param id the primary key of the current journal article
4264            * @param companyId the company ID
4265            * @param version the version
4266            * @param status the status
4267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4268            * @return the previous, current, and next journal article
4269            * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found
4270            * @throws SystemException if a system exception occurred
4271            */
4272            public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext(
4273                    long id, long companyId, double version, int status,
4274                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4275                    throws com.liferay.portal.kernel.exception.SystemException,
4276                            com.liferay.portlet.journal.NoSuchArticleException {
4277                    return getPersistence()
4278                                       .findByC_V_ST_PrevAndNext(id, companyId, version, status,
4279                            orderByComparator);
4280            }
4281    
4282            /**
4283            * Returns all the journal articles.
4284            *
4285            * @return the journal articles
4286            * @throws SystemException if a system exception occurred
4287            */
4288            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll()
4289                    throws com.liferay.portal.kernel.exception.SystemException {
4290                    return getPersistence().findAll();
4291            }
4292    
4293            /**
4294            * Returns a range of all the journal articles.
4295            *
4296            * <p>
4297            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4298            * </p>
4299            *
4300            * @param start the lower bound of the range of journal articles
4301            * @param end the upper bound of the range of journal articles (not inclusive)
4302            * @return the range of journal articles
4303            * @throws SystemException if a system exception occurred
4304            */
4305            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
4306                    int start, int end)
4307                    throws com.liferay.portal.kernel.exception.SystemException {
4308                    return getPersistence().findAll(start, end);
4309            }
4310    
4311            /**
4312            * Returns an ordered range of all the journal articles.
4313            *
4314            * <p>
4315            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4316            * </p>
4317            *
4318            * @param start the lower bound of the range of journal articles
4319            * @param end the upper bound of the range of journal articles (not inclusive)
4320            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4321            * @return the ordered range of journal articles
4322            * @throws SystemException if a system exception occurred
4323            */
4324            public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll(
4325                    int start, int end,
4326                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4327                    throws com.liferay.portal.kernel.exception.SystemException {
4328                    return getPersistence().findAll(start, end, orderByComparator);
4329            }
4330    
4331            /**
4332            * Removes all the journal articles where uuid = &#63; from the database.
4333            *
4334            * @param uuid the uuid
4335            * @throws SystemException if a system exception occurred
4336            */
4337            public static void removeByUuid(java.lang.String uuid)
4338                    throws com.liferay.portal.kernel.exception.SystemException {
4339                    getPersistence().removeByUuid(uuid);
4340            }
4341    
4342            /**
4343            * Removes the journal article where uuid = &#63; and groupId = &#63; from the database.
4344            *
4345            * @param uuid the uuid
4346            * @param groupId the group ID
4347            * @throws SystemException if a system exception occurred
4348            */
4349            public static void removeByUUID_G(java.lang.String uuid, long groupId)
4350                    throws com.liferay.portal.kernel.exception.SystemException,
4351                            com.liferay.portlet.journal.NoSuchArticleException {
4352                    getPersistence().removeByUUID_G(uuid, groupId);
4353            }
4354    
4355            /**
4356            * Removes all the journal articles where resourcePrimKey = &#63; from the database.
4357            *
4358            * @param resourcePrimKey the resource prim key
4359            * @throws SystemException if a system exception occurred
4360            */
4361            public static void removeByResourcePrimKey(long resourcePrimKey)
4362                    throws com.liferay.portal.kernel.exception.SystemException {
4363                    getPersistence().removeByResourcePrimKey(resourcePrimKey);
4364            }
4365    
4366            /**
4367            * Removes all the journal articles where groupId = &#63; from the database.
4368            *
4369            * @param groupId the group ID
4370            * @throws SystemException if a system exception occurred
4371            */
4372            public static void removeByGroupId(long groupId)
4373                    throws com.liferay.portal.kernel.exception.SystemException {
4374                    getPersistence().removeByGroupId(groupId);
4375            }
4376    
4377            /**
4378            * Removes all the journal articles where companyId = &#63; from the database.
4379            *
4380            * @param companyId the company ID
4381            * @throws SystemException if a system exception occurred
4382            */
4383            public static void removeByCompanyId(long companyId)
4384                    throws com.liferay.portal.kernel.exception.SystemException {
4385                    getPersistence().removeByCompanyId(companyId);
4386            }
4387    
4388            /**
4389            * Removes all the journal articles where structureId = &#63; from the database.
4390            *
4391            * @param structureId the structure ID
4392            * @throws SystemException if a system exception occurred
4393            */
4394            public static void removeByStructureId(java.lang.String structureId)
4395                    throws com.liferay.portal.kernel.exception.SystemException {
4396                    getPersistence().removeByStructureId(structureId);
4397            }
4398    
4399            /**
4400            * Removes all the journal articles where templateId = &#63; from the database.
4401            *
4402            * @param templateId the template ID
4403            * @throws SystemException if a system exception occurred
4404            */
4405            public static void removeByTemplateId(java.lang.String templateId)
4406                    throws com.liferay.portal.kernel.exception.SystemException {
4407                    getPersistence().removeByTemplateId(templateId);
4408            }
4409    
4410            /**
4411            * Removes all the journal articles where smallImageId = &#63; from the database.
4412            *
4413            * @param smallImageId the small image ID
4414            * @throws SystemException if a system exception occurred
4415            */
4416            public static void removeBySmallImageId(long smallImageId)
4417                    throws com.liferay.portal.kernel.exception.SystemException {
4418                    getPersistence().removeBySmallImageId(smallImageId);
4419            }
4420    
4421            /**
4422            * Removes all the journal articles where resourcePrimKey = &#63; and status = &#63; from the database.
4423            *
4424            * @param resourcePrimKey the resource prim key
4425            * @param status the status
4426            * @throws SystemException if a system exception occurred
4427            */
4428            public static void removeByR_ST(long resourcePrimKey, int status)
4429                    throws com.liferay.portal.kernel.exception.SystemException {
4430                    getPersistence().removeByR_ST(resourcePrimKey, status);
4431            }
4432    
4433            /**
4434            * Removes all the journal articles where groupId = &#63; and articleId = &#63; from the database.
4435            *
4436            * @param groupId the group ID
4437            * @param articleId the article ID
4438            * @throws SystemException if a system exception occurred
4439            */
4440            public static void removeByG_A(long groupId, java.lang.String articleId)
4441                    throws com.liferay.portal.kernel.exception.SystemException {
4442                    getPersistence().removeByG_A(groupId, articleId);
4443            }
4444    
4445            /**
4446            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; from the database.
4447            *
4448            * @param groupId the group ID
4449            * @param urlTitle the url title
4450            * @throws SystemException if a system exception occurred
4451            */
4452            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
4453                    throws com.liferay.portal.kernel.exception.SystemException {
4454                    getPersistence().removeByG_UT(groupId, urlTitle);
4455            }
4456    
4457            /**
4458            * Removes all the journal articles where groupId = &#63; and structureId = &#63; from the database.
4459            *
4460            * @param groupId the group ID
4461            * @param structureId the structure ID
4462            * @throws SystemException if a system exception occurred
4463            */
4464            public static void removeByG_S(long groupId, java.lang.String structureId)
4465                    throws com.liferay.portal.kernel.exception.SystemException {
4466                    getPersistence().removeByG_S(groupId, structureId);
4467            }
4468    
4469            /**
4470            * Removes all the journal articles where groupId = &#63; and templateId = &#63; from the database.
4471            *
4472            * @param groupId the group ID
4473            * @param templateId the template ID
4474            * @throws SystemException if a system exception occurred
4475            */
4476            public static void removeByG_T(long groupId, java.lang.String templateId)
4477                    throws com.liferay.portal.kernel.exception.SystemException {
4478                    getPersistence().removeByG_T(groupId, templateId);
4479            }
4480    
4481            /**
4482            * Removes all the journal articles where groupId = &#63; and layoutUuid = &#63; from the database.
4483            *
4484            * @param groupId the group ID
4485            * @param layoutUuid the layout uuid
4486            * @throws SystemException if a system exception occurred
4487            */
4488            public static void removeByG_L(long groupId, java.lang.String layoutUuid)
4489                    throws com.liferay.portal.kernel.exception.SystemException {
4490                    getPersistence().removeByG_L(groupId, layoutUuid);
4491            }
4492    
4493            /**
4494            * Removes all the journal articles where groupId = &#63; and status = &#63; from the database.
4495            *
4496            * @param groupId the group ID
4497            * @param status the status
4498            * @throws SystemException if a system exception occurred
4499            */
4500            public static void removeByG_ST(long groupId, int status)
4501                    throws com.liferay.portal.kernel.exception.SystemException {
4502                    getPersistence().removeByG_ST(groupId, status);
4503            }
4504    
4505            /**
4506            * Removes all the journal articles where companyId = &#63; and version = &#63; from the database.
4507            *
4508            * @param companyId the company ID
4509            * @param version the version
4510            * @throws SystemException if a system exception occurred
4511            */
4512            public static void removeByC_V(long companyId, double version)
4513                    throws com.liferay.portal.kernel.exception.SystemException {
4514                    getPersistence().removeByC_V(companyId, version);
4515            }
4516    
4517            /**
4518            * Removes all the journal articles where companyId = &#63; and status = &#63; from the database.
4519            *
4520            * @param companyId the company ID
4521            * @param status the status
4522            * @throws SystemException if a system exception occurred
4523            */
4524            public static void removeByC_ST(long companyId, int status)
4525                    throws com.liferay.portal.kernel.exception.SystemException {
4526                    getPersistence().removeByC_ST(companyId, status);
4527            }
4528    
4529            /**
4530            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
4531            *
4532            * @param groupId the group ID
4533            * @param classNameId the class name ID
4534            * @param classPK the class p k
4535            * @throws SystemException if a system exception occurred
4536            */
4537            public static void removeByG_C_C(long groupId, long classNameId,
4538                    long classPK)
4539                    throws com.liferay.portal.kernel.exception.SystemException {
4540                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
4541            }
4542    
4543            /**
4544            * Removes the journal article where groupId = &#63; and classNameId = &#63; and structureId = &#63; from the database.
4545            *
4546            * @param groupId the group ID
4547            * @param classNameId the class name ID
4548            * @param structureId the structure ID
4549            * @throws SystemException if a system exception occurred
4550            */
4551            public static void removeByG_C_S(long groupId, long classNameId,
4552                    java.lang.String structureId)
4553                    throws com.liferay.portal.kernel.exception.SystemException,
4554                            com.liferay.portlet.journal.NoSuchArticleException {
4555                    getPersistence().removeByG_C_S(groupId, classNameId, structureId);
4556            }
4557    
4558            /**
4559            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63; from the database.
4560            *
4561            * @param groupId the group ID
4562            * @param classNameId the class name ID
4563            * @param templateId the template ID
4564            * @throws SystemException if a system exception occurred
4565            */
4566            public static void removeByG_C_T(long groupId, long classNameId,
4567                    java.lang.String templateId)
4568                    throws com.liferay.portal.kernel.exception.SystemException {
4569                    getPersistence().removeByG_C_T(groupId, classNameId, templateId);
4570            }
4571    
4572            /**
4573            * Removes all the journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63; from the database.
4574            *
4575            * @param groupId the group ID
4576            * @param classNameId the class name ID
4577            * @param layoutUuid the layout uuid
4578            * @throws SystemException if a system exception occurred
4579            */
4580            public static void removeByG_C_L(long groupId, long classNameId,
4581                    java.lang.String layoutUuid)
4582                    throws com.liferay.portal.kernel.exception.SystemException {
4583                    getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid);
4584            }
4585    
4586            /**
4587            * Removes the journal article where groupId = &#63; and articleId = &#63; and version = &#63; from the database.
4588            *
4589            * @param groupId the group ID
4590            * @param articleId the article ID
4591            * @param version the version
4592            * @throws SystemException if a system exception occurred
4593            */
4594            public static void removeByG_A_V(long groupId, java.lang.String articleId,
4595                    double version)
4596                    throws com.liferay.portal.kernel.exception.SystemException,
4597                            com.liferay.portlet.journal.NoSuchArticleException {
4598                    getPersistence().removeByG_A_V(groupId, articleId, version);
4599            }
4600    
4601            /**
4602            * Removes all the journal articles where groupId = &#63; and articleId = &#63; and status = &#63; from the database.
4603            *
4604            * @param groupId the group ID
4605            * @param articleId the article ID
4606            * @param status the status
4607            * @throws SystemException if a system exception occurred
4608            */
4609            public static void removeByG_A_ST(long groupId, java.lang.String articleId,
4610                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4611                    getPersistence().removeByG_A_ST(groupId, articleId, status);
4612            }
4613    
4614            /**
4615            * Removes all the journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63; from the database.
4616            *
4617            * @param groupId the group ID
4618            * @param urlTitle the url title
4619            * @param status the status
4620            * @throws SystemException if a system exception occurred
4621            */
4622            public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle,
4623                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4624                    getPersistence().removeByG_UT_ST(groupId, urlTitle, status);
4625            }
4626    
4627            /**
4628            * Removes all the journal articles where companyId = &#63; and version = &#63; and status = &#63; from the database.
4629            *
4630            * @param companyId the company ID
4631            * @param version the version
4632            * @param status the status
4633            * @throws SystemException if a system exception occurred
4634            */
4635            public static void removeByC_V_ST(long companyId, double version, int status)
4636                    throws com.liferay.portal.kernel.exception.SystemException {
4637                    getPersistence().removeByC_V_ST(companyId, version, status);
4638            }
4639    
4640            /**
4641            * Removes all the journal articles from the database.
4642            *
4643            * @throws SystemException if a system exception occurred
4644            */
4645            public static void removeAll()
4646                    throws com.liferay.portal.kernel.exception.SystemException {
4647                    getPersistence().removeAll();
4648            }
4649    
4650            /**
4651            * Returns the number of journal articles where uuid = &#63;.
4652            *
4653            * @param uuid the uuid
4654            * @return the number of matching journal articles
4655            * @throws SystemException if a system exception occurred
4656            */
4657            public static int countByUuid(java.lang.String uuid)
4658                    throws com.liferay.portal.kernel.exception.SystemException {
4659                    return getPersistence().countByUuid(uuid);
4660            }
4661    
4662            /**
4663            * Returns the number of journal articles where uuid = &#63; and groupId = &#63;.
4664            *
4665            * @param uuid the uuid
4666            * @param groupId the group ID
4667            * @return the number of matching journal articles
4668            * @throws SystemException if a system exception occurred
4669            */
4670            public static int countByUUID_G(java.lang.String uuid, long groupId)
4671                    throws com.liferay.portal.kernel.exception.SystemException {
4672                    return getPersistence().countByUUID_G(uuid, groupId);
4673            }
4674    
4675            /**
4676            * Returns the number of journal articles where resourcePrimKey = &#63;.
4677            *
4678            * @param resourcePrimKey the resource prim key
4679            * @return the number of matching journal articles
4680            * @throws SystemException if a system exception occurred
4681            */
4682            public static int countByResourcePrimKey(long resourcePrimKey)
4683                    throws com.liferay.portal.kernel.exception.SystemException {
4684                    return getPersistence().countByResourcePrimKey(resourcePrimKey);
4685            }
4686    
4687            /**
4688            * Returns the number of journal articles where groupId = &#63;.
4689            *
4690            * @param groupId the group ID
4691            * @return the number of matching journal articles
4692            * @throws SystemException if a system exception occurred
4693            */
4694            public static int countByGroupId(long groupId)
4695                    throws com.liferay.portal.kernel.exception.SystemException {
4696                    return getPersistence().countByGroupId(groupId);
4697            }
4698    
4699            /**
4700            * Returns the number of journal articles that the user has permission to view where groupId = &#63;.
4701            *
4702            * @param groupId the group ID
4703            * @return the number of matching journal articles that the user has permission to view
4704            * @throws SystemException if a system exception occurred
4705            */
4706            public static int filterCountByGroupId(long groupId)
4707                    throws com.liferay.portal.kernel.exception.SystemException {
4708                    return getPersistence().filterCountByGroupId(groupId);
4709            }
4710    
4711            /**
4712            * Returns the number of journal articles where companyId = &#63;.
4713            *
4714            * @param companyId the company ID
4715            * @return the number of matching journal articles
4716            * @throws SystemException if a system exception occurred
4717            */
4718            public static int countByCompanyId(long companyId)
4719                    throws com.liferay.portal.kernel.exception.SystemException {
4720                    return getPersistence().countByCompanyId(companyId);
4721            }
4722    
4723            /**
4724            * Returns the number of journal articles where structureId = &#63;.
4725            *
4726            * @param structureId the structure ID
4727            * @return the number of matching journal articles
4728            * @throws SystemException if a system exception occurred
4729            */
4730            public static int countByStructureId(java.lang.String structureId)
4731                    throws com.liferay.portal.kernel.exception.SystemException {
4732                    return getPersistence().countByStructureId(structureId);
4733            }
4734    
4735            /**
4736            * Returns the number of journal articles where templateId = &#63;.
4737            *
4738            * @param templateId the template ID
4739            * @return the number of matching journal articles
4740            * @throws SystemException if a system exception occurred
4741            */
4742            public static int countByTemplateId(java.lang.String templateId)
4743                    throws com.liferay.portal.kernel.exception.SystemException {
4744                    return getPersistence().countByTemplateId(templateId);
4745            }
4746    
4747            /**
4748            * Returns the number of journal articles where smallImageId = &#63;.
4749            *
4750            * @param smallImageId the small image ID
4751            * @return the number of matching journal articles
4752            * @throws SystemException if a system exception occurred
4753            */
4754            public static int countBySmallImageId(long smallImageId)
4755                    throws com.liferay.portal.kernel.exception.SystemException {
4756                    return getPersistence().countBySmallImageId(smallImageId);
4757            }
4758    
4759            /**
4760            * Returns the number of journal articles where resourcePrimKey = &#63; and status = &#63;.
4761            *
4762            * @param resourcePrimKey the resource prim key
4763            * @param status the status
4764            * @return the number of matching journal articles
4765            * @throws SystemException if a system exception occurred
4766            */
4767            public static int countByR_ST(long resourcePrimKey, int status)
4768                    throws com.liferay.portal.kernel.exception.SystemException {
4769                    return getPersistence().countByR_ST(resourcePrimKey, status);
4770            }
4771    
4772            /**
4773            * Returns the number of journal articles where groupId = &#63; and articleId = &#63;.
4774            *
4775            * @param groupId the group ID
4776            * @param articleId the article ID
4777            * @return the number of matching journal articles
4778            * @throws SystemException if a system exception occurred
4779            */
4780            public static int countByG_A(long groupId, java.lang.String articleId)
4781                    throws com.liferay.portal.kernel.exception.SystemException {
4782                    return getPersistence().countByG_A(groupId, articleId);
4783            }
4784    
4785            /**
4786            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63;.
4787            *
4788            * @param groupId the group ID
4789            * @param articleId the article ID
4790            * @return the number of matching journal articles that the user has permission to view
4791            * @throws SystemException if a system exception occurred
4792            */
4793            public static int filterCountByG_A(long groupId, java.lang.String articleId)
4794                    throws com.liferay.portal.kernel.exception.SystemException {
4795                    return getPersistence().filterCountByG_A(groupId, articleId);
4796            }
4797    
4798            /**
4799            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63;.
4800            *
4801            * @param groupId the group ID
4802            * @param urlTitle the url title
4803            * @return the number of matching journal articles
4804            * @throws SystemException if a system exception occurred
4805            */
4806            public static int countByG_UT(long groupId, java.lang.String urlTitle)
4807                    throws com.liferay.portal.kernel.exception.SystemException {
4808                    return getPersistence().countByG_UT(groupId, urlTitle);
4809            }
4810    
4811            /**
4812            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63;.
4813            *
4814            * @param groupId the group ID
4815            * @param urlTitle the url title
4816            * @return the number of matching journal articles that the user has permission to view
4817            * @throws SystemException if a system exception occurred
4818            */
4819            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
4820                    throws com.liferay.portal.kernel.exception.SystemException {
4821                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
4822            }
4823    
4824            /**
4825            * Returns the number of journal articles where groupId = &#63; and structureId = &#63;.
4826            *
4827            * @param groupId the group ID
4828            * @param structureId the structure ID
4829            * @return the number of matching journal articles
4830            * @throws SystemException if a system exception occurred
4831            */
4832            public static int countByG_S(long groupId, java.lang.String structureId)
4833                    throws com.liferay.portal.kernel.exception.SystemException {
4834                    return getPersistence().countByG_S(groupId, structureId);
4835            }
4836    
4837            /**
4838            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and structureId = &#63;.
4839            *
4840            * @param groupId the group ID
4841            * @param structureId the structure ID
4842            * @return the number of matching journal articles that the user has permission to view
4843            * @throws SystemException if a system exception occurred
4844            */
4845            public static int filterCountByG_S(long groupId,
4846                    java.lang.String structureId)
4847                    throws com.liferay.portal.kernel.exception.SystemException {
4848                    return getPersistence().filterCountByG_S(groupId, structureId);
4849            }
4850    
4851            /**
4852            * Returns the number of journal articles where groupId = &#63; and templateId = &#63;.
4853            *
4854            * @param groupId the group ID
4855            * @param templateId the template ID
4856            * @return the number of matching journal articles
4857            * @throws SystemException if a system exception occurred
4858            */
4859            public static int countByG_T(long groupId, java.lang.String templateId)
4860                    throws com.liferay.portal.kernel.exception.SystemException {
4861                    return getPersistence().countByG_T(groupId, templateId);
4862            }
4863    
4864            /**
4865            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and templateId = &#63;.
4866            *
4867            * @param groupId the group ID
4868            * @param templateId the template ID
4869            * @return the number of matching journal articles that the user has permission to view
4870            * @throws SystemException if a system exception occurred
4871            */
4872            public static int filterCountByG_T(long groupId, java.lang.String templateId)
4873                    throws com.liferay.portal.kernel.exception.SystemException {
4874                    return getPersistence().filterCountByG_T(groupId, templateId);
4875            }
4876    
4877            /**
4878            * Returns the number of journal articles where groupId = &#63; and layoutUuid = &#63;.
4879            *
4880            * @param groupId the group ID
4881            * @param layoutUuid the layout uuid
4882            * @return the number of matching journal articles
4883            * @throws SystemException if a system exception occurred
4884            */
4885            public static int countByG_L(long groupId, java.lang.String layoutUuid)
4886                    throws com.liferay.portal.kernel.exception.SystemException {
4887                    return getPersistence().countByG_L(groupId, layoutUuid);
4888            }
4889    
4890            /**
4891            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and layoutUuid = &#63;.
4892            *
4893            * @param groupId the group ID
4894            * @param layoutUuid the layout uuid
4895            * @return the number of matching journal articles that the user has permission to view
4896            * @throws SystemException if a system exception occurred
4897            */
4898            public static int filterCountByG_L(long groupId, java.lang.String layoutUuid)
4899                    throws com.liferay.portal.kernel.exception.SystemException {
4900                    return getPersistence().filterCountByG_L(groupId, layoutUuid);
4901            }
4902    
4903            /**
4904            * Returns the number of journal articles where groupId = &#63; and status = &#63;.
4905            *
4906            * @param groupId the group ID
4907            * @param status the status
4908            * @return the number of matching journal articles
4909            * @throws SystemException if a system exception occurred
4910            */
4911            public static int countByG_ST(long groupId, int status)
4912                    throws com.liferay.portal.kernel.exception.SystemException {
4913                    return getPersistence().countByG_ST(groupId, status);
4914            }
4915    
4916            /**
4917            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and status = &#63;.
4918            *
4919            * @param groupId the group ID
4920            * @param status the status
4921            * @return the number of matching journal articles that the user has permission to view
4922            * @throws SystemException if a system exception occurred
4923            */
4924            public static int filterCountByG_ST(long groupId, int status)
4925                    throws com.liferay.portal.kernel.exception.SystemException {
4926                    return getPersistence().filterCountByG_ST(groupId, status);
4927            }
4928    
4929            /**
4930            * Returns the number of journal articles where companyId = &#63; and version = &#63;.
4931            *
4932            * @param companyId the company ID
4933            * @param version the version
4934            * @return the number of matching journal articles
4935            * @throws SystemException if a system exception occurred
4936            */
4937            public static int countByC_V(long companyId, double version)
4938                    throws com.liferay.portal.kernel.exception.SystemException {
4939                    return getPersistence().countByC_V(companyId, version);
4940            }
4941    
4942            /**
4943            * Returns the number of journal articles where companyId = &#63; and status = &#63;.
4944            *
4945            * @param companyId the company ID
4946            * @param status the status
4947            * @return the number of matching journal articles
4948            * @throws SystemException if a system exception occurred
4949            */
4950            public static int countByC_ST(long companyId, int status)
4951                    throws com.liferay.portal.kernel.exception.SystemException {
4952                    return getPersistence().countByC_ST(companyId, status);
4953            }
4954    
4955            /**
4956            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4957            *
4958            * @param groupId the group ID
4959            * @param classNameId the class name ID
4960            * @param classPK the class p k
4961            * @return the number of matching journal articles
4962            * @throws SystemException if a system exception occurred
4963            */
4964            public static int countByG_C_C(long groupId, long classNameId, long classPK)
4965                    throws com.liferay.portal.kernel.exception.SystemException {
4966                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
4967            }
4968    
4969            /**
4970            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
4971            *
4972            * @param groupId the group ID
4973            * @param classNameId the class name ID
4974            * @param classPK the class p k
4975            * @return the number of matching journal articles that the user has permission to view
4976            * @throws SystemException if a system exception occurred
4977            */
4978            public static int filterCountByG_C_C(long groupId, long classNameId,
4979                    long classPK)
4980                    throws com.liferay.portal.kernel.exception.SystemException {
4981                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
4982            }
4983    
4984            /**
4985            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and structureId = &#63;.
4986            *
4987            * @param groupId the group ID
4988            * @param classNameId the class name ID
4989            * @param structureId the structure ID
4990            * @return the number of matching journal articles
4991            * @throws SystemException if a system exception occurred
4992            */
4993            public static int countByG_C_S(long groupId, long classNameId,
4994                    java.lang.String structureId)
4995                    throws com.liferay.portal.kernel.exception.SystemException {
4996                    return getPersistence().countByG_C_S(groupId, classNameId, structureId);
4997            }
4998    
4999            /**
5000            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5001            *
5002            * @param groupId the group ID
5003            * @param classNameId the class name ID
5004            * @param templateId the template ID
5005            * @return the number of matching journal articles
5006            * @throws SystemException if a system exception occurred
5007            */
5008            public static int countByG_C_T(long groupId, long classNameId,
5009                    java.lang.String templateId)
5010                    throws com.liferay.portal.kernel.exception.SystemException {
5011                    return getPersistence().countByG_C_T(groupId, classNameId, templateId);
5012            }
5013    
5014            /**
5015            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and templateId = &#63;.
5016            *
5017            * @param groupId the group ID
5018            * @param classNameId the class name ID
5019            * @param templateId the template ID
5020            * @return the number of matching journal articles that the user has permission to view
5021            * @throws SystemException if a system exception occurred
5022            */
5023            public static int filterCountByG_C_T(long groupId, long classNameId,
5024                    java.lang.String templateId)
5025                    throws com.liferay.portal.kernel.exception.SystemException {
5026                    return getPersistence()
5027                                       .filterCountByG_C_T(groupId, classNameId, templateId);
5028            }
5029    
5030            /**
5031            * Returns the number of journal articles where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5032            *
5033            * @param groupId the group ID
5034            * @param classNameId the class name ID
5035            * @param layoutUuid the layout uuid
5036            * @return the number of matching journal articles
5037            * @throws SystemException if a system exception occurred
5038            */
5039            public static int countByG_C_L(long groupId, long classNameId,
5040                    java.lang.String layoutUuid)
5041                    throws com.liferay.portal.kernel.exception.SystemException {
5042                    return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid);
5043            }
5044    
5045            /**
5046            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and classNameId = &#63; and layoutUuid = &#63;.
5047            *
5048            * @param groupId the group ID
5049            * @param classNameId the class name ID
5050            * @param layoutUuid the layout uuid
5051            * @return the number of matching journal articles that the user has permission to view
5052            * @throws SystemException if a system exception occurred
5053            */
5054            public static int filterCountByG_C_L(long groupId, long classNameId,
5055                    java.lang.String layoutUuid)
5056                    throws com.liferay.portal.kernel.exception.SystemException {
5057                    return getPersistence()
5058                                       .filterCountByG_C_L(groupId, classNameId, layoutUuid);
5059            }
5060    
5061            /**
5062            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and version = &#63;.
5063            *
5064            * @param groupId the group ID
5065            * @param articleId the article ID
5066            * @param version the version
5067            * @return the number of matching journal articles
5068            * @throws SystemException if a system exception occurred
5069            */
5070            public static int countByG_A_V(long groupId, java.lang.String articleId,
5071                    double version)
5072                    throws com.liferay.portal.kernel.exception.SystemException {
5073                    return getPersistence().countByG_A_V(groupId, articleId, version);
5074            }
5075    
5076            /**
5077            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = &#63;.
5078            *
5079            * @param groupId the group ID
5080            * @param articleId the article ID
5081            * @param status the status
5082            * @return the number of matching journal articles
5083            * @throws SystemException if a system exception occurred
5084            */
5085            public static int countByG_A_ST(long groupId, java.lang.String articleId,
5086                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5087                    return getPersistence().countByG_A_ST(groupId, articleId, status);
5088            }
5089    
5090            /**
5091            * Returns the number of journal articles where groupId = &#63; and articleId = &#63; and status = any &#63;.
5092            *
5093            * @param groupId the group ID
5094            * @param articleId the article ID
5095            * @param statuses the statuses
5096            * @return the number of matching journal articles
5097            * @throws SystemException if a system exception occurred
5098            */
5099            public static int countByG_A_ST(long groupId, java.lang.String articleId,
5100                    int[] statuses)
5101                    throws com.liferay.portal.kernel.exception.SystemException {
5102                    return getPersistence().countByG_A_ST(groupId, articleId, statuses);
5103            }
5104    
5105            /**
5106            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = &#63;.
5107            *
5108            * @param groupId the group ID
5109            * @param articleId the article ID
5110            * @param status the status
5111            * @return the number of matching journal articles that the user has permission to view
5112            * @throws SystemException if a system exception occurred
5113            */
5114            public static int filterCountByG_A_ST(long groupId,
5115                    java.lang.String articleId, int status)
5116                    throws com.liferay.portal.kernel.exception.SystemException {
5117                    return getPersistence().filterCountByG_A_ST(groupId, articleId, status);
5118            }
5119    
5120            /**
5121            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and articleId = &#63; and status = any &#63;.
5122            *
5123            * @param groupId the group ID
5124            * @param articleId the article ID
5125            * @param statuses the statuses
5126            * @return the number of matching journal articles that the user has permission to view
5127            * @throws SystemException if a system exception occurred
5128            */
5129            public static int filterCountByG_A_ST(long groupId,
5130                    java.lang.String articleId, int[] statuses)
5131                    throws com.liferay.portal.kernel.exception.SystemException {
5132                    return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses);
5133            }
5134    
5135            /**
5136            * Returns the number of journal articles where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5137            *
5138            * @param groupId the group ID
5139            * @param urlTitle the url title
5140            * @param status the status
5141            * @return the number of matching journal articles
5142            * @throws SystemException if a system exception occurred
5143            */
5144            public static int countByG_UT_ST(long groupId, java.lang.String urlTitle,
5145                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5146                    return getPersistence().countByG_UT_ST(groupId, urlTitle, status);
5147            }
5148    
5149            /**
5150            * Returns the number of journal articles that the user has permission to view where groupId = &#63; and urlTitle = &#63; and status = &#63;.
5151            *
5152            * @param groupId the group ID
5153            * @param urlTitle the url title
5154            * @param status the status
5155            * @return the number of matching journal articles that the user has permission to view
5156            * @throws SystemException if a system exception occurred
5157            */
5158            public static int filterCountByG_UT_ST(long groupId,
5159                    java.lang.String urlTitle, int status)
5160                    throws com.liferay.portal.kernel.exception.SystemException {
5161                    return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status);
5162            }
5163    
5164            /**
5165            * Returns the number of journal articles where companyId = &#63; and version = &#63; and status = &#63;.
5166            *
5167            * @param companyId the company ID
5168            * @param version the version
5169            * @param status the status
5170            * @return the number of matching journal articles
5171            * @throws SystemException if a system exception occurred
5172            */
5173            public static int countByC_V_ST(long companyId, double version, int status)
5174                    throws com.liferay.portal.kernel.exception.SystemException {
5175                    return getPersistence().countByC_V_ST(companyId, version, status);
5176            }
5177    
5178            /**
5179            * Returns the number of journal articles.
5180            *
5181            * @return the number of journal articles
5182            * @throws SystemException if a system exception occurred
5183            */
5184            public static int countAll()
5185                    throws com.liferay.portal.kernel.exception.SystemException {
5186                    return getPersistence().countAll();
5187            }
5188    
5189            public static JournalArticlePersistence getPersistence() {
5190                    if (_persistence == null) {
5191                            _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName());
5192    
5193                            ReferenceRegistry.registerReference(JournalArticleUtil.class,
5194                                    "_persistence");
5195                    }
5196    
5197                    return _persistence;
5198            }
5199    
5200            public void setPersistence(JournalArticlePersistence persistence) {
5201                    _persistence = persistence;
5202    
5203                    ReferenceRegistry.registerReference(JournalArticleUtil.class,
5204                            "_persistence");
5205            }
5206    
5207            private static JournalArticlePersistence _persistence;
5208    }