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