001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.journal.model.JournalFeed;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the journal feed service. This utility wraps {@link com.liferay.portlet.journal.service.persistence.impl.JournalFeedPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see JournalFeedPersistence
038     * @see com.liferay.portlet.journal.service.persistence.impl.JournalFeedPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class JournalFeedUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(JournalFeed journalFeed) {
060                    getPersistence().clearCache(journalFeed);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<JournalFeed> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<JournalFeed> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<JournalFeed> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<JournalFeed> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static JournalFeed update(JournalFeed journalFeed) {
101                    return getPersistence().update(journalFeed);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static JournalFeed update(JournalFeed journalFeed,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(journalFeed, serviceContext);
110            }
111    
112            /**
113            * Returns all the journal feeds where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching journal feeds
117            */
118            public static List<JournalFeed> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the journal feeds where uuid = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of journal feeds
131            * @param end the upper bound of the range of journal feeds (not inclusive)
132            * @return the range of matching journal feeds
133            */
134            public static List<JournalFeed> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the journal feeds where uuid = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of journal feeds
148            * @param end the upper bound of the range of journal feeds (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching journal feeds
151            */
152            public static List<JournalFeed> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<JournalFeed> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first journal feed in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching journal feed
163            * @throws NoSuchFeedException if a matching journal feed could not be found
164            */
165            public static JournalFeed findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<JournalFeed> orderByComparator)
167                    throws com.liferay.portlet.journal.NoSuchFeedException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first journal feed in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching journal feed, or <code>null</code> if a matching journal feed could not be found
177            */
178            public static JournalFeed fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<JournalFeed> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last journal feed in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching journal feed
189            * @throws NoSuchFeedException if a matching journal feed could not be found
190            */
191            public static JournalFeed findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<JournalFeed> orderByComparator)
193                    throws com.liferay.portlet.journal.NoSuchFeedException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last journal feed in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching journal feed, or <code>null</code> if a matching journal feed could not be found
203            */
204            public static JournalFeed fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<JournalFeed> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the journal feeds before and after the current journal feed in the ordered set where uuid = &#63;.
211            *
212            * @param id the primary key of the current journal feed
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next journal feed
216            * @throws NoSuchFeedException if a journal feed with the primary key could not be found
217            */
218            public static JournalFeed[] findByUuid_PrevAndNext(long id,
219                    java.lang.String uuid, OrderByComparator<JournalFeed> orderByComparator)
220                    throws com.liferay.portlet.journal.NoSuchFeedException {
221                    return getPersistence()
222                                       .findByUuid_PrevAndNext(id, uuid, orderByComparator);
223            }
224    
225            /**
226            * Removes all the journal feeds where uuid = &#63; from the database.
227            *
228            * @param uuid the uuid
229            */
230            public static void removeByUuid(java.lang.String uuid) {
231                    getPersistence().removeByUuid(uuid);
232            }
233    
234            /**
235            * Returns the number of journal feeds where uuid = &#63;.
236            *
237            * @param uuid the uuid
238            * @return the number of matching journal feeds
239            */
240            public static int countByUuid(java.lang.String uuid) {
241                    return getPersistence().countByUuid(uuid);
242            }
243    
244            /**
245            * Returns the journal feed where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFeedException} if it could not be found.
246            *
247            * @param uuid the uuid
248            * @param groupId the group ID
249            * @return the matching journal feed
250            * @throws NoSuchFeedException if a matching journal feed could not be found
251            */
252            public static JournalFeed findByUUID_G(java.lang.String uuid, long groupId)
253                    throws com.liferay.portlet.journal.NoSuchFeedException {
254                    return getPersistence().findByUUID_G(uuid, groupId);
255            }
256    
257            /**
258            * Returns the journal feed where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
259            *
260            * @param uuid the uuid
261            * @param groupId the group ID
262            * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found
263            */
264            public static JournalFeed fetchByUUID_G(java.lang.String uuid, long groupId) {
265                    return getPersistence().fetchByUUID_G(uuid, groupId);
266            }
267    
268            /**
269            * Returns the journal feed where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @param retrieveFromCache whether to use the finder cache
274            * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found
275            */
276            public static JournalFeed fetchByUUID_G(java.lang.String uuid,
277                    long groupId, boolean retrieveFromCache) {
278                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
279            }
280    
281            /**
282            * Removes the journal feed where uuid = &#63; and groupId = &#63; from the database.
283            *
284            * @param uuid the uuid
285            * @param groupId the group ID
286            * @return the journal feed that was removed
287            */
288            public static JournalFeed removeByUUID_G(java.lang.String uuid, long groupId)
289                    throws com.liferay.portlet.journal.NoSuchFeedException {
290                    return getPersistence().removeByUUID_G(uuid, groupId);
291            }
292    
293            /**
294            * Returns the number of journal feeds where uuid = &#63; and groupId = &#63;.
295            *
296            * @param uuid the uuid
297            * @param groupId the group ID
298            * @return the number of matching journal feeds
299            */
300            public static int countByUUID_G(java.lang.String uuid, long groupId) {
301                    return getPersistence().countByUUID_G(uuid, groupId);
302            }
303    
304            /**
305            * Returns all the journal feeds where uuid = &#63; and companyId = &#63;.
306            *
307            * @param uuid the uuid
308            * @param companyId the company ID
309            * @return the matching journal feeds
310            */
311            public static List<JournalFeed> findByUuid_C(java.lang.String uuid,
312                    long companyId) {
313                    return getPersistence().findByUuid_C(uuid, companyId);
314            }
315    
316            /**
317            * Returns a range of all the journal feeds where uuid = &#63; and companyId = &#63;.
318            *
319            * <p>
320            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
321            * </p>
322            *
323            * @param uuid the uuid
324            * @param companyId the company ID
325            * @param start the lower bound of the range of journal feeds
326            * @param end the upper bound of the range of journal feeds (not inclusive)
327            * @return the range of matching journal feeds
328            */
329            public static List<JournalFeed> findByUuid_C(java.lang.String uuid,
330                    long companyId, int start, int end) {
331                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
332            }
333    
334            /**
335            * Returns an ordered range of all the journal feeds where uuid = &#63; and companyId = &#63;.
336            *
337            * <p>
338            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
339            * </p>
340            *
341            * @param uuid the uuid
342            * @param companyId the company ID
343            * @param start the lower bound of the range of journal feeds
344            * @param end the upper bound of the range of journal feeds (not inclusive)
345            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
346            * @return the ordered range of matching journal feeds
347            */
348            public static List<JournalFeed> findByUuid_C(java.lang.String uuid,
349                    long companyId, int start, int end,
350                    OrderByComparator<JournalFeed> orderByComparator) {
351                    return getPersistence()
352                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
353            }
354    
355            /**
356            * Returns the first journal feed in the ordered set where uuid = &#63; and companyId = &#63;.
357            *
358            * @param uuid the uuid
359            * @param companyId the company ID
360            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
361            * @return the first matching journal feed
362            * @throws NoSuchFeedException if a matching journal feed could not be found
363            */
364            public static JournalFeed findByUuid_C_First(java.lang.String uuid,
365                    long companyId, OrderByComparator<JournalFeed> orderByComparator)
366                    throws com.liferay.portlet.journal.NoSuchFeedException {
367                    return getPersistence()
368                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
369            }
370    
371            /**
372            * Returns the first journal feed in the ordered set where uuid = &#63; and companyId = &#63;.
373            *
374            * @param uuid the uuid
375            * @param companyId the company ID
376            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
377            * @return the first matching journal feed, or <code>null</code> if a matching journal feed could not be found
378            */
379            public static JournalFeed fetchByUuid_C_First(java.lang.String uuid,
380                    long companyId, OrderByComparator<JournalFeed> orderByComparator) {
381                    return getPersistence()
382                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
383            }
384    
385            /**
386            * Returns the last journal feed in the ordered set where uuid = &#63; and companyId = &#63;.
387            *
388            * @param uuid the uuid
389            * @param companyId the company ID
390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
391            * @return the last matching journal feed
392            * @throws NoSuchFeedException if a matching journal feed could not be found
393            */
394            public static JournalFeed findByUuid_C_Last(java.lang.String uuid,
395                    long companyId, OrderByComparator<JournalFeed> orderByComparator)
396                    throws com.liferay.portlet.journal.NoSuchFeedException {
397                    return getPersistence()
398                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
399            }
400    
401            /**
402            * Returns the last journal feed in the ordered set where uuid = &#63; and companyId = &#63;.
403            *
404            * @param uuid the uuid
405            * @param companyId the company ID
406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
407            * @return the last matching journal feed, or <code>null</code> if a matching journal feed could not be found
408            */
409            public static JournalFeed fetchByUuid_C_Last(java.lang.String uuid,
410                    long companyId, OrderByComparator<JournalFeed> orderByComparator) {
411                    return getPersistence()
412                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
413            }
414    
415            /**
416            * Returns the journal feeds before and after the current journal feed in the ordered set where uuid = &#63; and companyId = &#63;.
417            *
418            * @param id the primary key of the current journal feed
419            * @param uuid the uuid
420            * @param companyId the company ID
421            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
422            * @return the previous, current, and next journal feed
423            * @throws NoSuchFeedException if a journal feed with the primary key could not be found
424            */
425            public static JournalFeed[] findByUuid_C_PrevAndNext(long id,
426                    java.lang.String uuid, long companyId,
427                    OrderByComparator<JournalFeed> orderByComparator)
428                    throws com.liferay.portlet.journal.NoSuchFeedException {
429                    return getPersistence()
430                                       .findByUuid_C_PrevAndNext(id, uuid, companyId,
431                            orderByComparator);
432            }
433    
434            /**
435            * Removes all the journal feeds where uuid = &#63; and companyId = &#63; from the database.
436            *
437            * @param uuid the uuid
438            * @param companyId the company ID
439            */
440            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
441                    getPersistence().removeByUuid_C(uuid, companyId);
442            }
443    
444            /**
445            * Returns the number of journal feeds where uuid = &#63; and companyId = &#63;.
446            *
447            * @param uuid the uuid
448            * @param companyId the company ID
449            * @return the number of matching journal feeds
450            */
451            public static int countByUuid_C(java.lang.String uuid, long companyId) {
452                    return getPersistence().countByUuid_C(uuid, companyId);
453            }
454    
455            /**
456            * Returns all the journal feeds where groupId = &#63;.
457            *
458            * @param groupId the group ID
459            * @return the matching journal feeds
460            */
461            public static List<JournalFeed> findByGroupId(long groupId) {
462                    return getPersistence().findByGroupId(groupId);
463            }
464    
465            /**
466            * Returns a range of all the journal feeds where groupId = &#63;.
467            *
468            * <p>
469            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
470            * </p>
471            *
472            * @param groupId the group ID
473            * @param start the lower bound of the range of journal feeds
474            * @param end the upper bound of the range of journal feeds (not inclusive)
475            * @return the range of matching journal feeds
476            */
477            public static List<JournalFeed> findByGroupId(long groupId, int start,
478                    int end) {
479                    return getPersistence().findByGroupId(groupId, start, end);
480            }
481    
482            /**
483            * Returns an ordered range of all the journal feeds where groupId = &#63;.
484            *
485            * <p>
486            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
487            * </p>
488            *
489            * @param groupId the group ID
490            * @param start the lower bound of the range of journal feeds
491            * @param end the upper bound of the range of journal feeds (not inclusive)
492            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
493            * @return the ordered range of matching journal feeds
494            */
495            public static List<JournalFeed> findByGroupId(long groupId, int start,
496                    int end, OrderByComparator<JournalFeed> orderByComparator) {
497                    return getPersistence()
498                                       .findByGroupId(groupId, start, end, orderByComparator);
499            }
500    
501            /**
502            * Returns the first journal feed in the ordered set where groupId = &#63;.
503            *
504            * @param groupId the group ID
505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
506            * @return the first matching journal feed
507            * @throws NoSuchFeedException if a matching journal feed could not be found
508            */
509            public static JournalFeed findByGroupId_First(long groupId,
510                    OrderByComparator<JournalFeed> orderByComparator)
511                    throws com.liferay.portlet.journal.NoSuchFeedException {
512                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
513            }
514    
515            /**
516            * Returns the first journal feed in the ordered set where groupId = &#63;.
517            *
518            * @param groupId the group ID
519            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
520            * @return the first matching journal feed, or <code>null</code> if a matching journal feed could not be found
521            */
522            public static JournalFeed fetchByGroupId_First(long groupId,
523                    OrderByComparator<JournalFeed> orderByComparator) {
524                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
525            }
526    
527            /**
528            * Returns the last journal feed in the ordered set where groupId = &#63;.
529            *
530            * @param groupId the group ID
531            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
532            * @return the last matching journal feed
533            * @throws NoSuchFeedException if a matching journal feed could not be found
534            */
535            public static JournalFeed findByGroupId_Last(long groupId,
536                    OrderByComparator<JournalFeed> orderByComparator)
537                    throws com.liferay.portlet.journal.NoSuchFeedException {
538                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
539            }
540    
541            /**
542            * Returns the last journal feed in the ordered set where groupId = &#63;.
543            *
544            * @param groupId the group ID
545            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
546            * @return the last matching journal feed, or <code>null</code> if a matching journal feed could not be found
547            */
548            public static JournalFeed fetchByGroupId_Last(long groupId,
549                    OrderByComparator<JournalFeed> orderByComparator) {
550                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
551            }
552    
553            /**
554            * Returns the journal feeds before and after the current journal feed in the ordered set where groupId = &#63;.
555            *
556            * @param id the primary key of the current journal feed
557            * @param groupId the group ID
558            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
559            * @return the previous, current, and next journal feed
560            * @throws NoSuchFeedException if a journal feed with the primary key could not be found
561            */
562            public static JournalFeed[] findByGroupId_PrevAndNext(long id,
563                    long groupId, OrderByComparator<JournalFeed> orderByComparator)
564                    throws com.liferay.portlet.journal.NoSuchFeedException {
565                    return getPersistence()
566                                       .findByGroupId_PrevAndNext(id, groupId, orderByComparator);
567            }
568    
569            /**
570            * Returns all the journal feeds that the user has permission to view where groupId = &#63;.
571            *
572            * @param groupId the group ID
573            * @return the matching journal feeds that the user has permission to view
574            */
575            public static List<JournalFeed> filterFindByGroupId(long groupId) {
576                    return getPersistence().filterFindByGroupId(groupId);
577            }
578    
579            /**
580            * Returns a range of all the journal feeds that the user has permission to view where groupId = &#63;.
581            *
582            * <p>
583            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
584            * </p>
585            *
586            * @param groupId the group ID
587            * @param start the lower bound of the range of journal feeds
588            * @param end the upper bound of the range of journal feeds (not inclusive)
589            * @return the range of matching journal feeds that the user has permission to view
590            */
591            public static List<JournalFeed> filterFindByGroupId(long groupId,
592                    int start, int end) {
593                    return getPersistence().filterFindByGroupId(groupId, start, end);
594            }
595    
596            /**
597            * Returns an ordered range of all the journal feeds that the user has permissions to view where groupId = &#63;.
598            *
599            * <p>
600            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
601            * </p>
602            *
603            * @param groupId the group ID
604            * @param start the lower bound of the range of journal feeds
605            * @param end the upper bound of the range of journal feeds (not inclusive)
606            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
607            * @return the ordered range of matching journal feeds that the user has permission to view
608            */
609            public static List<JournalFeed> filterFindByGroupId(long groupId,
610                    int start, int end, OrderByComparator<JournalFeed> orderByComparator) {
611                    return getPersistence()
612                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
613            }
614    
615            /**
616            * Returns the journal feeds before and after the current journal feed in the ordered set of journal feeds that the user has permission to view where groupId = &#63;.
617            *
618            * @param id the primary key of the current journal feed
619            * @param groupId the group ID
620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
621            * @return the previous, current, and next journal feed
622            * @throws NoSuchFeedException if a journal feed with the primary key could not be found
623            */
624            public static JournalFeed[] filterFindByGroupId_PrevAndNext(long id,
625                    long groupId, OrderByComparator<JournalFeed> orderByComparator)
626                    throws com.liferay.portlet.journal.NoSuchFeedException {
627                    return getPersistence()
628                                       .filterFindByGroupId_PrevAndNext(id, groupId,
629                            orderByComparator);
630            }
631    
632            /**
633            * Removes all the journal feeds where groupId = &#63; from the database.
634            *
635            * @param groupId the group ID
636            */
637            public static void removeByGroupId(long groupId) {
638                    getPersistence().removeByGroupId(groupId);
639            }
640    
641            /**
642            * Returns the number of journal feeds where groupId = &#63;.
643            *
644            * @param groupId the group ID
645            * @return the number of matching journal feeds
646            */
647            public static int countByGroupId(long groupId) {
648                    return getPersistence().countByGroupId(groupId);
649            }
650    
651            /**
652            * Returns the number of journal feeds that the user has permission to view where groupId = &#63;.
653            *
654            * @param groupId the group ID
655            * @return the number of matching journal feeds that the user has permission to view
656            */
657            public static int filterCountByGroupId(long groupId) {
658                    return getPersistence().filterCountByGroupId(groupId);
659            }
660    
661            /**
662            * Returns the journal feed where groupId = &#63; and feedId = &#63; or throws a {@link NoSuchFeedException} if it could not be found.
663            *
664            * @param groupId the group ID
665            * @param feedId the feed ID
666            * @return the matching journal feed
667            * @throws NoSuchFeedException if a matching journal feed could not be found
668            */
669            public static JournalFeed findByG_F(long groupId, java.lang.String feedId)
670                    throws com.liferay.portlet.journal.NoSuchFeedException {
671                    return getPersistence().findByG_F(groupId, feedId);
672            }
673    
674            /**
675            * Returns the journal feed where groupId = &#63; and feedId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
676            *
677            * @param groupId the group ID
678            * @param feedId the feed ID
679            * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found
680            */
681            public static JournalFeed fetchByG_F(long groupId, java.lang.String feedId) {
682                    return getPersistence().fetchByG_F(groupId, feedId);
683            }
684    
685            /**
686            * Returns the journal feed where groupId = &#63; and feedId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
687            *
688            * @param groupId the group ID
689            * @param feedId the feed ID
690            * @param retrieveFromCache whether to use the finder cache
691            * @return the matching journal feed, or <code>null</code> if a matching journal feed could not be found
692            */
693            public static JournalFeed fetchByG_F(long groupId, java.lang.String feedId,
694                    boolean retrieveFromCache) {
695                    return getPersistence().fetchByG_F(groupId, feedId, retrieveFromCache);
696            }
697    
698            /**
699            * Removes the journal feed where groupId = &#63; and feedId = &#63; from the database.
700            *
701            * @param groupId the group ID
702            * @param feedId the feed ID
703            * @return the journal feed that was removed
704            */
705            public static JournalFeed removeByG_F(long groupId, java.lang.String feedId)
706                    throws com.liferay.portlet.journal.NoSuchFeedException {
707                    return getPersistence().removeByG_F(groupId, feedId);
708            }
709    
710            /**
711            * Returns the number of journal feeds where groupId = &#63; and feedId = &#63;.
712            *
713            * @param groupId the group ID
714            * @param feedId the feed ID
715            * @return the number of matching journal feeds
716            */
717            public static int countByG_F(long groupId, java.lang.String feedId) {
718                    return getPersistence().countByG_F(groupId, feedId);
719            }
720    
721            /**
722            * Caches the journal feed in the entity cache if it is enabled.
723            *
724            * @param journalFeed the journal feed
725            */
726            public static void cacheResult(JournalFeed journalFeed) {
727                    getPersistence().cacheResult(journalFeed);
728            }
729    
730            /**
731            * Caches the journal feeds in the entity cache if it is enabled.
732            *
733            * @param journalFeeds the journal feeds
734            */
735            public static void cacheResult(List<JournalFeed> journalFeeds) {
736                    getPersistence().cacheResult(journalFeeds);
737            }
738    
739            /**
740            * Creates a new journal feed with the primary key. Does not add the journal feed to the database.
741            *
742            * @param id the primary key for the new journal feed
743            * @return the new journal feed
744            */
745            public static JournalFeed create(long id) {
746                    return getPersistence().create(id);
747            }
748    
749            /**
750            * Removes the journal feed with the primary key from the database. Also notifies the appropriate model listeners.
751            *
752            * @param id the primary key of the journal feed
753            * @return the journal feed that was removed
754            * @throws NoSuchFeedException if a journal feed with the primary key could not be found
755            */
756            public static JournalFeed remove(long id)
757                    throws com.liferay.portlet.journal.NoSuchFeedException {
758                    return getPersistence().remove(id);
759            }
760    
761            public static JournalFeed updateImpl(JournalFeed journalFeed) {
762                    return getPersistence().updateImpl(journalFeed);
763            }
764    
765            /**
766            * Returns the journal feed with the primary key or throws a {@link NoSuchFeedException} if it could not be found.
767            *
768            * @param id the primary key of the journal feed
769            * @return the journal feed
770            * @throws NoSuchFeedException if a journal feed with the primary key could not be found
771            */
772            public static JournalFeed findByPrimaryKey(long id)
773                    throws com.liferay.portlet.journal.NoSuchFeedException {
774                    return getPersistence().findByPrimaryKey(id);
775            }
776    
777            /**
778            * Returns the journal feed with the primary key or returns <code>null</code> if it could not be found.
779            *
780            * @param id the primary key of the journal feed
781            * @return the journal feed, or <code>null</code> if a journal feed with the primary key could not be found
782            */
783            public static JournalFeed fetchByPrimaryKey(long id) {
784                    return getPersistence().fetchByPrimaryKey(id);
785            }
786    
787            public static java.util.Map<java.io.Serializable, JournalFeed> fetchByPrimaryKeys(
788                    java.util.Set<java.io.Serializable> primaryKeys) {
789                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
790            }
791    
792            /**
793            * Returns all the journal feeds.
794            *
795            * @return the journal feeds
796            */
797            public static List<JournalFeed> findAll() {
798                    return getPersistence().findAll();
799            }
800    
801            /**
802            * Returns a range of all the journal feeds.
803            *
804            * <p>
805            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
806            * </p>
807            *
808            * @param start the lower bound of the range of journal feeds
809            * @param end the upper bound of the range of journal feeds (not inclusive)
810            * @return the range of journal feeds
811            */
812            public static List<JournalFeed> findAll(int start, int end) {
813                    return getPersistence().findAll(start, end);
814            }
815    
816            /**
817            * Returns an ordered range of all the journal feeds.
818            *
819            * <p>
820            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFeedModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
821            * </p>
822            *
823            * @param start the lower bound of the range of journal feeds
824            * @param end the upper bound of the range of journal feeds (not inclusive)
825            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
826            * @return the ordered range of journal feeds
827            */
828            public static List<JournalFeed> findAll(int start, int end,
829                    OrderByComparator<JournalFeed> orderByComparator) {
830                    return getPersistence().findAll(start, end, orderByComparator);
831            }
832    
833            /**
834            * Removes all the journal feeds from the database.
835            */
836            public static void removeAll() {
837                    getPersistence().removeAll();
838            }
839    
840            /**
841            * Returns the number of journal feeds.
842            *
843            * @return the number of journal feeds
844            */
845            public static int countAll() {
846                    return getPersistence().countAll();
847            }
848    
849            public static JournalFeedPersistence getPersistence() {
850                    if (_persistence == null) {
851                            _persistence = (JournalFeedPersistence)PortalBeanLocatorUtil.locate(JournalFeedPersistence.class.getName());
852    
853                            ReferenceRegistry.registerReference(JournalFeedUtil.class,
854                                    "_persistence");
855                    }
856    
857                    return _persistence;
858            }
859    
860            /**
861             * @deprecated As of 6.2.0
862             */
863            @Deprecated
864            public void setPersistence(JournalFeedPersistence persistence) {
865            }
866    
867            private static JournalFeedPersistence _persistence;
868    }