001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portlet.announcements.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.announcements.model.AnnouncementsEntry;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the announcements entry service. This utility wraps {@link AnnouncementsEntryPersistenceImpl} 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 AnnouncementsEntryPersistence
037     * @see AnnouncementsEntryPersistenceImpl
038     * @generated
039     */
040    public class AnnouncementsEntryUtil {
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(AnnouncementsEntry announcementsEntry) {
058                    getPersistence().clearCache(announcementsEntry);
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<AnnouncementsEntry> 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<AnnouncementsEntry> 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<AnnouncementsEntry> 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#remove(com.liferay.portal.model.BaseModel)
099             */
100            public static AnnouncementsEntry remove(
101                    AnnouncementsEntry announcementsEntry) throws SystemException {
102                    return getPersistence().remove(announcementsEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
107             */
108            public static AnnouncementsEntry update(
109                    AnnouncementsEntry announcementsEntry, boolean merge)
110                    throws SystemException {
111                    return getPersistence().update(announcementsEntry, merge);
112            }
113    
114            /**
115             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
116             */
117            public static AnnouncementsEntry update(
118                    AnnouncementsEntry announcementsEntry, boolean merge,
119                    ServiceContext serviceContext) throws SystemException {
120                    return getPersistence().update(announcementsEntry, merge, serviceContext);
121            }
122    
123            /**
124            * Caches the announcements entry in the entity cache if it is enabled.
125            *
126            * @param announcementsEntry the announcements entry to cache
127            */
128            public static void cacheResult(
129                    com.liferay.portlet.announcements.model.AnnouncementsEntry announcementsEntry) {
130                    getPersistence().cacheResult(announcementsEntry);
131            }
132    
133            /**
134            * Caches the announcements entries in the entity cache if it is enabled.
135            *
136            * @param announcementsEntries the announcements entries to cache
137            */
138            public static void cacheResult(
139                    java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> announcementsEntries) {
140                    getPersistence().cacheResult(announcementsEntries);
141            }
142    
143            /**
144            * Creates a new announcements entry with the primary key. Does not add the announcements entry to the database.
145            *
146            * @param entryId the primary key for the new announcements entry
147            * @return the new announcements entry
148            */
149            public static com.liferay.portlet.announcements.model.AnnouncementsEntry create(
150                    long entryId) {
151                    return getPersistence().create(entryId);
152            }
153    
154            /**
155            * Removes the announcements entry with the primary key from the database. Also notifies the appropriate model listeners.
156            *
157            * @param entryId the primary key of the announcements entry to remove
158            * @return the announcements entry that was removed
159            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
160            * @throws SystemException if a system exception occurred
161            */
162            public static com.liferay.portlet.announcements.model.AnnouncementsEntry remove(
163                    long entryId)
164                    throws com.liferay.portal.kernel.exception.SystemException,
165                            com.liferay.portlet.announcements.NoSuchEntryException {
166                    return getPersistence().remove(entryId);
167            }
168    
169            public static com.liferay.portlet.announcements.model.AnnouncementsEntry updateImpl(
170                    com.liferay.portlet.announcements.model.AnnouncementsEntry announcementsEntry,
171                    boolean merge)
172                    throws com.liferay.portal.kernel.exception.SystemException {
173                    return getPersistence().updateImpl(announcementsEntry, merge);
174            }
175    
176            /**
177            * Finds the announcements entry with the primary key or throws a {@link com.liferay.portlet.announcements.NoSuchEntryException} if it could not be found.
178            *
179            * @param entryId the primary key of the announcements entry to find
180            * @return the announcements entry
181            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
182            * @throws SystemException if a system exception occurred
183            */
184            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByPrimaryKey(
185                    long entryId)
186                    throws com.liferay.portal.kernel.exception.SystemException,
187                            com.liferay.portlet.announcements.NoSuchEntryException {
188                    return getPersistence().findByPrimaryKey(entryId);
189            }
190    
191            /**
192            * Finds the announcements entry with the primary key or returns <code>null</code> if it could not be found.
193            *
194            * @param entryId the primary key of the announcements entry to find
195            * @return the announcements entry, or <code>null</code> if a announcements entry with the primary key could not be found
196            * @throws SystemException if a system exception occurred
197            */
198            public static com.liferay.portlet.announcements.model.AnnouncementsEntry fetchByPrimaryKey(
199                    long entryId)
200                    throws com.liferay.portal.kernel.exception.SystemException {
201                    return getPersistence().fetchByPrimaryKey(entryId);
202            }
203    
204            /**
205            * Finds all the announcements entries where uuid = &#63;.
206            *
207            * @param uuid the uuid to search with
208            * @return the matching announcements entries
209            * @throws SystemException if a system exception occurred
210            */
211            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid(
212                    java.lang.String uuid)
213                    throws com.liferay.portal.kernel.exception.SystemException {
214                    return getPersistence().findByUuid(uuid);
215            }
216    
217            /**
218            * Finds a range of all the announcements entries where uuid = &#63;.
219            *
220            * <p>
221            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
222            * </p>
223            *
224            * @param uuid the uuid to search with
225            * @param start the lower bound of the range of announcements entries to return
226            * @param end the upper bound of the range of announcements entries to return (not inclusive)
227            * @return the range of matching announcements entries
228            * @throws SystemException if a system exception occurred
229            */
230            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid(
231                    java.lang.String uuid, int start, int end)
232                    throws com.liferay.portal.kernel.exception.SystemException {
233                    return getPersistence().findByUuid(uuid, start, end);
234            }
235    
236            /**
237            * Finds an ordered range of all the announcements entries where uuid = &#63;.
238            *
239            * <p>
240            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
241            * </p>
242            *
243            * @param uuid the uuid to search with
244            * @param start the lower bound of the range of announcements entries to return
245            * @param end the upper bound of the range of announcements entries to return (not inclusive)
246            * @param orderByComparator the comparator to order the results by
247            * @return the ordered range of matching announcements entries
248            * @throws SystemException if a system exception occurred
249            */
250            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUuid(
251                    java.lang.String uuid, int start, int end,
252                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
253                    throws com.liferay.portal.kernel.exception.SystemException {
254                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
255            }
256    
257            /**
258            * Finds the first announcements entry in the ordered set where uuid = &#63;.
259            *
260            * <p>
261            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
262            * </p>
263            *
264            * @param uuid the uuid to search with
265            * @param orderByComparator the comparator to order the set by
266            * @return the first matching announcements entry
267            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
268            * @throws SystemException if a system exception occurred
269            */
270            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_First(
271                    java.lang.String uuid,
272                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
273                    throws com.liferay.portal.kernel.exception.SystemException,
274                            com.liferay.portlet.announcements.NoSuchEntryException {
275                    return getPersistence().findByUuid_First(uuid, orderByComparator);
276            }
277    
278            /**
279            * Finds the last announcements entry in the ordered set where uuid = &#63;.
280            *
281            * <p>
282            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
283            * </p>
284            *
285            * @param uuid the uuid to search with
286            * @param orderByComparator the comparator to order the set by
287            * @return the last matching announcements entry
288            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
289            * @throws SystemException if a system exception occurred
290            */
291            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_Last(
292                    java.lang.String uuid,
293                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
294                    throws com.liferay.portal.kernel.exception.SystemException,
295                            com.liferay.portlet.announcements.NoSuchEntryException {
296                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
297            }
298    
299            /**
300            * Finds the announcements entries before and after the current announcements entry in the ordered set where uuid = &#63;.
301            *
302            * <p>
303            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
304            * </p>
305            *
306            * @param entryId the primary key of the current announcements entry
307            * @param uuid the uuid to search with
308            * @param orderByComparator the comparator to order the set by
309            * @return the previous, current, and next announcements entry
310            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
311            * @throws SystemException if a system exception occurred
312            */
313            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUuid_PrevAndNext(
314                    long entryId, java.lang.String uuid,
315                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
316                    throws com.liferay.portal.kernel.exception.SystemException,
317                            com.liferay.portlet.announcements.NoSuchEntryException {
318                    return getPersistence()
319                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
320            }
321    
322            /**
323            * Filters by the user's permissions and finds all the announcements entries where uuid = &#63;.
324            *
325            * @param uuid the uuid to search with
326            * @return the matching announcements entries that the user has permission to view
327            * @throws SystemException if a system exception occurred
328            */
329            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid(
330                    java.lang.String uuid)
331                    throws com.liferay.portal.kernel.exception.SystemException {
332                    return getPersistence().filterFindByUuid(uuid);
333            }
334    
335            /**
336            * Filters by the user's permissions and finds a range of all the announcements entries where uuid = &#63;.
337            *
338            * <p>
339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
340            * </p>
341            *
342            * @param uuid the uuid to search with
343            * @param start the lower bound of the range of announcements entries to return
344            * @param end the upper bound of the range of announcements entries to return (not inclusive)
345            * @return the range of matching announcements entries that the user has permission to view
346            * @throws SystemException if a system exception occurred
347            */
348            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid(
349                    java.lang.String uuid, int start, int end)
350                    throws com.liferay.portal.kernel.exception.SystemException {
351                    return getPersistence().filterFindByUuid(uuid, start, end);
352            }
353    
354            /**
355            * Filters by the user's permissions and finds an ordered range of all the announcements entries where uuid = &#63;.
356            *
357            * <p>
358            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
359            * </p>
360            *
361            * @param uuid the uuid to search with
362            * @param start the lower bound of the range of announcements entries to return
363            * @param end the upper bound of the range of announcements entries to return (not inclusive)
364            * @param orderByComparator the comparator to order the results by
365            * @return the ordered range of matching announcements entries that the user has permission to view
366            * @throws SystemException if a system exception occurred
367            */
368            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid(
369                    java.lang.String uuid, int start, int end,
370                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
371                    throws com.liferay.portal.kernel.exception.SystemException {
372                    return getPersistence()
373                                       .filterFindByUuid(uuid, start, end, orderByComparator);
374            }
375    
376            /**
377            * Filters the announcements entries before and after the current announcements entry in the ordered set where uuid = &#63;.
378            *
379            * <p>
380            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
381            * </p>
382            *
383            * @param entryId the primary key of the current announcements entry
384            * @param uuid the uuid to search with
385            * @param orderByComparator the comparator to order the set by
386            * @return the previous, current, and next announcements entry
387            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
388            * @throws SystemException if a system exception occurred
389            */
390            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUuid_PrevAndNext(
391                    long entryId, java.lang.String uuid,
392                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
393                    throws com.liferay.portal.kernel.exception.SystemException,
394                            com.liferay.portlet.announcements.NoSuchEntryException {
395                    return getPersistence()
396                                       .filterFindByUuid_PrevAndNext(entryId, uuid,
397                            orderByComparator);
398            }
399    
400            /**
401            * Finds all the announcements entries where userId = &#63;.
402            *
403            * @param userId the user ID to search with
404            * @return the matching announcements entries
405            * @throws SystemException if a system exception occurred
406            */
407            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId(
408                    long userId) throws com.liferay.portal.kernel.exception.SystemException {
409                    return getPersistence().findByUserId(userId);
410            }
411    
412            /**
413            * Finds a range of all the announcements entries where userId = &#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 userId the user ID to search with
420            * @param start the lower bound of the range of announcements entries to return
421            * @param end the upper bound of the range of announcements entries to return (not inclusive)
422            * @return the range of matching announcements entries
423            * @throws SystemException if a system exception occurred
424            */
425            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId(
426                    long userId, int start, int end)
427                    throws com.liferay.portal.kernel.exception.SystemException {
428                    return getPersistence().findByUserId(userId, start, end);
429            }
430    
431            /**
432            * Finds an ordered range of all the announcements entries where userId = &#63;.
433            *
434            * <p>
435            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
436            * </p>
437            *
438            * @param userId the user ID to search with
439            * @param start the lower bound of the range of announcements entries to return
440            * @param end the upper bound of the range of announcements entries to return (not inclusive)
441            * @param orderByComparator the comparator to order the results by
442            * @return the ordered range of matching announcements entries
443            * @throws SystemException if a system exception occurred
444            */
445            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId(
446                    long userId, int start, int end,
447                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
448                    throws com.liferay.portal.kernel.exception.SystemException {
449                    return getPersistence()
450                                       .findByUserId(userId, start, end, orderByComparator);
451            }
452    
453            /**
454            * Finds the first announcements entry in the ordered set where userId = &#63;.
455            *
456            * <p>
457            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
458            * </p>
459            *
460            * @param userId the user ID to search with
461            * @param orderByComparator the comparator to order the set by
462            * @return the first matching announcements entry
463            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_First(
467                    long userId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException,
470                            com.liferay.portlet.announcements.NoSuchEntryException {
471                    return getPersistence().findByUserId_First(userId, orderByComparator);
472            }
473    
474            /**
475            * Finds the last announcements entry in the ordered set where userId = &#63;.
476            *
477            * <p>
478            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
479            * </p>
480            *
481            * @param userId the user ID to search with
482            * @param orderByComparator the comparator to order the set by
483            * @return the last matching announcements entry
484            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
485            * @throws SystemException if a system exception occurred
486            */
487            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_Last(
488                    long userId,
489                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
490                    throws com.liferay.portal.kernel.exception.SystemException,
491                            com.liferay.portlet.announcements.NoSuchEntryException {
492                    return getPersistence().findByUserId_Last(userId, orderByComparator);
493            }
494    
495            /**
496            * Finds the announcements entries before and after the current announcements entry in the ordered set where userId = &#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 entryId the primary key of the current announcements entry
503            * @param userId the user ID to search with
504            * @param orderByComparator the comparator to order the set by
505            * @return the previous, current, and next announcements entry
506            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
507            * @throws SystemException if a system exception occurred
508            */
509            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUserId_PrevAndNext(
510                    long entryId, long userId,
511                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
512                    throws com.liferay.portal.kernel.exception.SystemException,
513                            com.liferay.portlet.announcements.NoSuchEntryException {
514                    return getPersistence()
515                                       .findByUserId_PrevAndNext(entryId, userId, orderByComparator);
516            }
517    
518            /**
519            * Filters by the user's permissions and finds all the announcements entries where userId = &#63;.
520            *
521            * @param userId the user ID to search with
522            * @return the matching announcements entries that the user has permission to view
523            * @throws SystemException if a system exception occurred
524            */
525            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId(
526                    long userId) throws com.liferay.portal.kernel.exception.SystemException {
527                    return getPersistence().filterFindByUserId(userId);
528            }
529    
530            /**
531            * Filters by the user's permissions and finds a range of all the announcements entries where userId = &#63;.
532            *
533            * <p>
534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
535            * </p>
536            *
537            * @param userId the user ID to search with
538            * @param start the lower bound of the range of announcements entries to return
539            * @param end the upper bound of the range of announcements entries to return (not inclusive)
540            * @return the range of matching announcements entries that the user has permission to view
541            * @throws SystemException if a system exception occurred
542            */
543            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId(
544                    long userId, int start, int end)
545                    throws com.liferay.portal.kernel.exception.SystemException {
546                    return getPersistence().filterFindByUserId(userId, start, end);
547            }
548    
549            /**
550            * Filters by the user's permissions and finds an ordered range of all the announcements entries where userId = &#63;.
551            *
552            * <p>
553            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
554            * </p>
555            *
556            * @param userId the user ID to search with
557            * @param start the lower bound of the range of announcements entries to return
558            * @param end the upper bound of the range of announcements entries to return (not inclusive)
559            * @param orderByComparator the comparator to order the results by
560            * @return the ordered range of matching announcements entries that the user has permission to view
561            * @throws SystemException if a system exception occurred
562            */
563            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId(
564                    long userId, int start, int end,
565                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
566                    throws com.liferay.portal.kernel.exception.SystemException {
567                    return getPersistence()
568                                       .filterFindByUserId(userId, start, end, orderByComparator);
569            }
570    
571            /**
572            * Filters the announcements entries before and after the current announcements entry in the ordered set where userId = &#63;.
573            *
574            * <p>
575            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
576            * </p>
577            *
578            * @param entryId the primary key of the current announcements entry
579            * @param userId the user ID to search with
580            * @param orderByComparator the comparator to order the set by
581            * @return the previous, current, and next announcements entry
582            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
583            * @throws SystemException if a system exception occurred
584            */
585            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUserId_PrevAndNext(
586                    long entryId, long userId,
587                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
588                    throws com.liferay.portal.kernel.exception.SystemException,
589                            com.liferay.portlet.announcements.NoSuchEntryException {
590                    return getPersistence()
591                                       .filterFindByUserId_PrevAndNext(entryId, userId,
592                            orderByComparator);
593            }
594    
595            /**
596            * Finds all the announcements entries where classNameId = &#63; and classPK = &#63;.
597            *
598            * @param classNameId the class name ID to search with
599            * @param classPK the class p k to search with
600            * @return the matching announcements entries
601            * @throws SystemException if a system exception occurred
602            */
603            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C(
604                    long classNameId, long classPK)
605                    throws com.liferay.portal.kernel.exception.SystemException {
606                    return getPersistence().findByC_C(classNameId, classPK);
607            }
608    
609            /**
610            * Finds a range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
611            *
612            * <p>
613            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
614            * </p>
615            *
616            * @param classNameId the class name ID to search with
617            * @param classPK the class p k to search with
618            * @param start the lower bound of the range of announcements entries to return
619            * @param end the upper bound of the range of announcements entries to return (not inclusive)
620            * @return the range of matching announcements entries
621            * @throws SystemException if a system exception occurred
622            */
623            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C(
624                    long classNameId, long classPK, int start, int end)
625                    throws com.liferay.portal.kernel.exception.SystemException {
626                    return getPersistence().findByC_C(classNameId, classPK, start, end);
627            }
628    
629            /**
630            * Finds an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
631            *
632            * <p>
633            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
634            * </p>
635            *
636            * @param classNameId the class name ID to search with
637            * @param classPK the class p k to search with
638            * @param start the lower bound of the range of announcements entries to return
639            * @param end the upper bound of the range of announcements entries to return (not inclusive)
640            * @param orderByComparator the comparator to order the results by
641            * @return the ordered range of matching announcements entries
642            * @throws SystemException if a system exception occurred
643            */
644            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C(
645                    long classNameId, long classPK, int start, int end,
646                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
647                    throws com.liferay.portal.kernel.exception.SystemException {
648                    return getPersistence()
649                                       .findByC_C(classNameId, classPK, start, end,
650                            orderByComparator);
651            }
652    
653            /**
654            * Finds the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
655            *
656            * <p>
657            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
658            * </p>
659            *
660            * @param classNameId the class name ID to search with
661            * @param classPK the class p k to search with
662            * @param orderByComparator the comparator to order the set by
663            * @return the first matching announcements entry
664            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
665            * @throws SystemException if a system exception occurred
666            */
667            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_First(
668                    long classNameId, long classPK,
669                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
670                    throws com.liferay.portal.kernel.exception.SystemException,
671                            com.liferay.portlet.announcements.NoSuchEntryException {
672                    return getPersistence()
673                                       .findByC_C_First(classNameId, classPK, orderByComparator);
674            }
675    
676            /**
677            * Finds the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
678            *
679            * <p>
680            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
681            * </p>
682            *
683            * @param classNameId the class name ID to search with
684            * @param classPK the class p k to search with
685            * @param orderByComparator the comparator to order the set by
686            * @return the last matching announcements entry
687            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
688            * @throws SystemException if a system exception occurred
689            */
690            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_Last(
691                    long classNameId, long classPK,
692                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
693                    throws com.liferay.portal.kernel.exception.SystemException,
694                            com.liferay.portlet.announcements.NoSuchEntryException {
695                    return getPersistence()
696                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
697            }
698    
699            /**
700            * Finds the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
701            *
702            * <p>
703            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
704            * </p>
705            *
706            * @param entryId the primary key of the current announcements entry
707            * @param classNameId the class name ID to search with
708            * @param classPK the class p k to search with
709            * @param orderByComparator the comparator to order the set by
710            * @return the previous, current, and next announcements entry
711            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
712            * @throws SystemException if a system exception occurred
713            */
714            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_PrevAndNext(
715                    long entryId, long classNameId, long classPK,
716                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
717                    throws com.liferay.portal.kernel.exception.SystemException,
718                            com.liferay.portlet.announcements.NoSuchEntryException {
719                    return getPersistence()
720                                       .findByC_C_PrevAndNext(entryId, classNameId, classPK,
721                            orderByComparator);
722            }
723    
724            /**
725            * Filters by the user's permissions and finds all the announcements entries where classNameId = &#63; and classPK = &#63;.
726            *
727            * @param classNameId the class name ID to search with
728            * @param classPK the class p k to search with
729            * @return the matching announcements entries that the user has permission to view
730            * @throws SystemException if a system exception occurred
731            */
732            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C(
733                    long classNameId, long classPK)
734                    throws com.liferay.portal.kernel.exception.SystemException {
735                    return getPersistence().filterFindByC_C(classNameId, classPK);
736            }
737    
738            /**
739            * Filters by the user's permissions and finds a range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
740            *
741            * <p>
742            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
743            * </p>
744            *
745            * @param classNameId the class name ID to search with
746            * @param classPK the class p k to search with
747            * @param start the lower bound of the range of announcements entries to return
748            * @param end the upper bound of the range of announcements entries to return (not inclusive)
749            * @return the range of matching announcements entries that the user has permission to view
750            * @throws SystemException if a system exception occurred
751            */
752            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C(
753                    long classNameId, long classPK, int start, int end)
754                    throws com.liferay.portal.kernel.exception.SystemException {
755                    return getPersistence().filterFindByC_C(classNameId, classPK, start, end);
756            }
757    
758            /**
759            * Filters by the user's permissions and finds an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
760            *
761            * <p>
762            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
763            * </p>
764            *
765            * @param classNameId the class name ID to search with
766            * @param classPK the class p k to search with
767            * @param start the lower bound of the range of announcements entries to return
768            * @param end the upper bound of the range of announcements entries to return (not inclusive)
769            * @param orderByComparator the comparator to order the results by
770            * @return the ordered range of matching announcements entries that the user has permission to view
771            * @throws SystemException if a system exception occurred
772            */
773            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C(
774                    long classNameId, long classPK, int start, int end,
775                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence()
778                                       .filterFindByC_C(classNameId, classPK, start, end,
779                            orderByComparator);
780            }
781    
782            /**
783            * Filters the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
784            *
785            * <p>
786            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
787            * </p>
788            *
789            * @param entryId the primary key of the current announcements entry
790            * @param classNameId the class name ID to search with
791            * @param classPK the class p k to search with
792            * @param orderByComparator the comparator to order the set by
793            * @return the previous, current, and next announcements entry
794            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
795            * @throws SystemException if a system exception occurred
796            */
797            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_PrevAndNext(
798                    long entryId, long classNameId, long classPK,
799                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
800                    throws com.liferay.portal.kernel.exception.SystemException,
801                            com.liferay.portlet.announcements.NoSuchEntryException {
802                    return getPersistence()
803                                       .filterFindByC_C_PrevAndNext(entryId, classNameId, classPK,
804                            orderByComparator);
805            }
806    
807            /**
808            * Finds all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
809            *
810            * @param classNameId the class name ID to search with
811            * @param classPK the class p k to search with
812            * @param alert the alert to search with
813            * @return the matching announcements entries
814            * @throws SystemException if a system exception occurred
815            */
816            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A(
817                    long classNameId, long classPK, boolean alert)
818                    throws com.liferay.portal.kernel.exception.SystemException {
819                    return getPersistence().findByC_C_A(classNameId, classPK, alert);
820            }
821    
822            /**
823            * Finds a range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
824            *
825            * <p>
826            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
827            * </p>
828            *
829            * @param classNameId the class name ID to search with
830            * @param classPK the class p k to search with
831            * @param alert the alert to search with
832            * @param start the lower bound of the range of announcements entries to return
833            * @param end the upper bound of the range of announcements entries to return (not inclusive)
834            * @return the range of matching announcements entries
835            * @throws SystemException if a system exception occurred
836            */
837            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A(
838                    long classNameId, long classPK, boolean alert, int start, int end)
839                    throws com.liferay.portal.kernel.exception.SystemException {
840                    return getPersistence()
841                                       .findByC_C_A(classNameId, classPK, alert, start, end);
842            }
843    
844            /**
845            * Finds an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
846            *
847            * <p>
848            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
849            * </p>
850            *
851            * @param classNameId the class name ID to search with
852            * @param classPK the class p k to search with
853            * @param alert the alert to search with
854            * @param start the lower bound of the range of announcements entries to return
855            * @param end the upper bound of the range of announcements entries to return (not inclusive)
856            * @param orderByComparator the comparator to order the results by
857            * @return the ordered range of matching announcements entries
858            * @throws SystemException if a system exception occurred
859            */
860            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A(
861                    long classNameId, long classPK, boolean alert, int start, int end,
862                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
863                    throws com.liferay.portal.kernel.exception.SystemException {
864                    return getPersistence()
865                                       .findByC_C_A(classNameId, classPK, alert, start, end,
866                            orderByComparator);
867            }
868    
869            /**
870            * Finds the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
871            *
872            * <p>
873            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
874            * </p>
875            *
876            * @param classNameId the class name ID to search with
877            * @param classPK the class p k to search with
878            * @param alert the alert to search with
879            * @param orderByComparator the comparator to order the set by
880            * @return the first matching announcements entry
881            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
882            * @throws SystemException if a system exception occurred
883            */
884            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_First(
885                    long classNameId, long classPK, boolean alert,
886                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
887                    throws com.liferay.portal.kernel.exception.SystemException,
888                            com.liferay.portlet.announcements.NoSuchEntryException {
889                    return getPersistence()
890                                       .findByC_C_A_First(classNameId, classPK, alert,
891                            orderByComparator);
892            }
893    
894            /**
895            * Finds the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
896            *
897            * <p>
898            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
899            * </p>
900            *
901            * @param classNameId the class name ID to search with
902            * @param classPK the class p k to search with
903            * @param alert the alert to search with
904            * @param orderByComparator the comparator to order the set by
905            * @return the last matching announcements entry
906            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
907            * @throws SystemException if a system exception occurred
908            */
909            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_Last(
910                    long classNameId, long classPK, boolean alert,
911                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
912                    throws com.liferay.portal.kernel.exception.SystemException,
913                            com.liferay.portlet.announcements.NoSuchEntryException {
914                    return getPersistence()
915                                       .findByC_C_A_Last(classNameId, classPK, alert,
916                            orderByComparator);
917            }
918    
919            /**
920            * Finds the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
921            *
922            * <p>
923            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
924            * </p>
925            *
926            * @param entryId the primary key of the current announcements entry
927            * @param classNameId the class name ID to search with
928            * @param classPK the class p k to search with
929            * @param alert the alert to search with
930            * @param orderByComparator the comparator to order the set by
931            * @return the previous, current, and next announcements entry
932            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
933            * @throws SystemException if a system exception occurred
934            */
935            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_A_PrevAndNext(
936                    long entryId, long classNameId, long classPK, boolean alert,
937                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
938                    throws com.liferay.portal.kernel.exception.SystemException,
939                            com.liferay.portlet.announcements.NoSuchEntryException {
940                    return getPersistence()
941                                       .findByC_C_A_PrevAndNext(entryId, classNameId, classPK,
942                            alert, orderByComparator);
943            }
944    
945            /**
946            * Filters by the user's permissions and finds all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
947            *
948            * @param classNameId the class name ID to search with
949            * @param classPK the class p k to search with
950            * @param alert the alert to search with
951            * @return the matching announcements entries that the user has permission to view
952            * @throws SystemException if a system exception occurred
953            */
954            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A(
955                    long classNameId, long classPK, boolean alert)
956                    throws com.liferay.portal.kernel.exception.SystemException {
957                    return getPersistence().filterFindByC_C_A(classNameId, classPK, alert);
958            }
959    
960            /**
961            * Filters by the user's permissions and finds a range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
962            *
963            * <p>
964            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
965            * </p>
966            *
967            * @param classNameId the class name ID to search with
968            * @param classPK the class p k to search with
969            * @param alert the alert to search with
970            * @param start the lower bound of the range of announcements entries to return
971            * @param end the upper bound of the range of announcements entries to return (not inclusive)
972            * @return the range of matching announcements entries that the user has permission to view
973            * @throws SystemException if a system exception occurred
974            */
975            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A(
976                    long classNameId, long classPK, boolean alert, int start, int end)
977                    throws com.liferay.portal.kernel.exception.SystemException {
978                    return getPersistence()
979                                       .filterFindByC_C_A(classNameId, classPK, alert, start, end);
980            }
981    
982            /**
983            * Filters by the user's permissions and finds an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
984            *
985            * <p>
986            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
987            * </p>
988            *
989            * @param classNameId the class name ID to search with
990            * @param classPK the class p k to search with
991            * @param alert the alert to search with
992            * @param start the lower bound of the range of announcements entries to return
993            * @param end the upper bound of the range of announcements entries to return (not inclusive)
994            * @param orderByComparator the comparator to order the results by
995            * @return the ordered range of matching announcements entries that the user has permission to view
996            * @throws SystemException if a system exception occurred
997            */
998            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A(
999                    long classNameId, long classPK, boolean alert, int start, int end,
1000                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1001                    throws com.liferay.portal.kernel.exception.SystemException {
1002                    return getPersistence()
1003                                       .filterFindByC_C_A(classNameId, classPK, alert, start, end,
1004                            orderByComparator);
1005            }
1006    
1007            /**
1008            * Filters the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
1009            *
1010            * <p>
1011            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1012            * </p>
1013            *
1014            * @param entryId the primary key of the current announcements entry
1015            * @param classNameId the class name ID to search with
1016            * @param classPK the class p k to search with
1017            * @param alert the alert to search with
1018            * @param orderByComparator the comparator to order the set by
1019            * @return the previous, current, and next announcements entry
1020            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
1021            * @throws SystemException if a system exception occurred
1022            */
1023            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_A_PrevAndNext(
1024                    long entryId, long classNameId, long classPK, boolean alert,
1025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1026                    throws com.liferay.portal.kernel.exception.SystemException,
1027                            com.liferay.portlet.announcements.NoSuchEntryException {
1028                    return getPersistence()
1029                                       .filterFindByC_C_A_PrevAndNext(entryId, classNameId,
1030                            classPK, alert, orderByComparator);
1031            }
1032    
1033            /**
1034            * Finds all the announcements entries.
1035            *
1036            * @return the announcements entries
1037            * @throws SystemException if a system exception occurred
1038            */
1039            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll()
1040                    throws com.liferay.portal.kernel.exception.SystemException {
1041                    return getPersistence().findAll();
1042            }
1043    
1044            /**
1045            * Finds a range of all the announcements entries.
1046            *
1047            * <p>
1048            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1049            * </p>
1050            *
1051            * @param start the lower bound of the range of announcements entries to return
1052            * @param end the upper bound of the range of announcements entries to return (not inclusive)
1053            * @return the range of announcements entries
1054            * @throws SystemException if a system exception occurred
1055            */
1056            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll(
1057                    int start, int end)
1058                    throws com.liferay.portal.kernel.exception.SystemException {
1059                    return getPersistence().findAll(start, end);
1060            }
1061    
1062            /**
1063            * Finds an ordered range of all the announcements entries.
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 start the lower bound of the range of announcements entries to return
1070            * @param end the upper bound of the range of announcements entries to return (not inclusive)
1071            * @param orderByComparator the comparator to order the results by
1072            * @return the ordered range of announcements entries
1073            * @throws SystemException if a system exception occurred
1074            */
1075            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll(
1076                    int start, int end,
1077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1078                    throws com.liferay.portal.kernel.exception.SystemException {
1079                    return getPersistence().findAll(start, end, orderByComparator);
1080            }
1081    
1082            /**
1083            * Removes all the announcements entries where uuid = &#63; from the database.
1084            *
1085            * @param uuid the uuid to search with
1086            * @throws SystemException if a system exception occurred
1087            */
1088            public static void removeByUuid(java.lang.String uuid)
1089                    throws com.liferay.portal.kernel.exception.SystemException {
1090                    getPersistence().removeByUuid(uuid);
1091            }
1092    
1093            /**
1094            * Removes all the announcements entries where userId = &#63; from the database.
1095            *
1096            * @param userId the user ID to search with
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static void removeByUserId(long userId)
1100                    throws com.liferay.portal.kernel.exception.SystemException {
1101                    getPersistence().removeByUserId(userId);
1102            }
1103    
1104            /**
1105            * Removes all the announcements entries where classNameId = &#63; and classPK = &#63; from the database.
1106            *
1107            * @param classNameId the class name ID to search with
1108            * @param classPK the class p k to search with
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static void removeByC_C(long classNameId, long classPK)
1112                    throws com.liferay.portal.kernel.exception.SystemException {
1113                    getPersistence().removeByC_C(classNameId, classPK);
1114            }
1115    
1116            /**
1117            * Removes all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63; from the database.
1118            *
1119            * @param classNameId the class name ID to search with
1120            * @param classPK the class p k to search with
1121            * @param alert the alert to search with
1122            * @throws SystemException if a system exception occurred
1123            */
1124            public static void removeByC_C_A(long classNameId, long classPK,
1125                    boolean alert)
1126                    throws com.liferay.portal.kernel.exception.SystemException {
1127                    getPersistence().removeByC_C_A(classNameId, classPK, alert);
1128            }
1129    
1130            /**
1131            * Removes all the announcements entries from the database.
1132            *
1133            * @throws SystemException if a system exception occurred
1134            */
1135            public static void removeAll()
1136                    throws com.liferay.portal.kernel.exception.SystemException {
1137                    getPersistence().removeAll();
1138            }
1139    
1140            /**
1141            * Counts all the announcements entries where uuid = &#63;.
1142            *
1143            * @param uuid the uuid to search with
1144            * @return the number of matching announcements entries
1145            * @throws SystemException if a system exception occurred
1146            */
1147            public static int countByUuid(java.lang.String uuid)
1148                    throws com.liferay.portal.kernel.exception.SystemException {
1149                    return getPersistence().countByUuid(uuid);
1150            }
1151    
1152            /**
1153            * Filters by the user's permissions and counts all the announcements entries where uuid = &#63;.
1154            *
1155            * @param uuid the uuid to search with
1156            * @return the number of matching announcements entries that the user has permission to view
1157            * @throws SystemException if a system exception occurred
1158            */
1159            public static int filterCountByUuid(java.lang.String uuid)
1160                    throws com.liferay.portal.kernel.exception.SystemException {
1161                    return getPersistence().filterCountByUuid(uuid);
1162            }
1163    
1164            /**
1165            * Counts all the announcements entries where userId = &#63;.
1166            *
1167            * @param userId the user ID to search with
1168            * @return the number of matching announcements entries
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static int countByUserId(long userId)
1172                    throws com.liferay.portal.kernel.exception.SystemException {
1173                    return getPersistence().countByUserId(userId);
1174            }
1175    
1176            /**
1177            * Filters by the user's permissions and counts all the announcements entries where userId = &#63;.
1178            *
1179            * @param userId the user ID to search with
1180            * @return the number of matching announcements entries that the user has permission to view
1181            * @throws SystemException if a system exception occurred
1182            */
1183            public static int filterCountByUserId(long userId)
1184                    throws com.liferay.portal.kernel.exception.SystemException {
1185                    return getPersistence().filterCountByUserId(userId);
1186            }
1187    
1188            /**
1189            * Counts all the announcements entries where classNameId = &#63; and classPK = &#63;.
1190            *
1191            * @param classNameId the class name ID to search with
1192            * @param classPK the class p k to search with
1193            * @return the number of matching announcements entries
1194            * @throws SystemException if a system exception occurred
1195            */
1196            public static int countByC_C(long classNameId, long classPK)
1197                    throws com.liferay.portal.kernel.exception.SystemException {
1198                    return getPersistence().countByC_C(classNameId, classPK);
1199            }
1200    
1201            /**
1202            * Filters by the user's permissions and counts all the announcements entries where classNameId = &#63; and classPK = &#63;.
1203            *
1204            * @param classNameId the class name ID to search with
1205            * @param classPK the class p k to search with
1206            * @return the number of matching announcements entries that the user has permission to view
1207            * @throws SystemException if a system exception occurred
1208            */
1209            public static int filterCountByC_C(long classNameId, long classPK)
1210                    throws com.liferay.portal.kernel.exception.SystemException {
1211                    return getPersistence().filterCountByC_C(classNameId, classPK);
1212            }
1213    
1214            /**
1215            * Counts all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
1216            *
1217            * @param classNameId the class name ID to search with
1218            * @param classPK the class p k to search with
1219            * @param alert the alert to search with
1220            * @return the number of matching announcements entries
1221            * @throws SystemException if a system exception occurred
1222            */
1223            public static int countByC_C_A(long classNameId, long classPK, boolean alert)
1224                    throws com.liferay.portal.kernel.exception.SystemException {
1225                    return getPersistence().countByC_C_A(classNameId, classPK, alert);
1226            }
1227    
1228            /**
1229            * Filters by the user's permissions and counts all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
1230            *
1231            * @param classNameId the class name ID to search with
1232            * @param classPK the class p k to search with
1233            * @param alert the alert to search with
1234            * @return the number of matching announcements entries that the user has permission to view
1235            * @throws SystemException if a system exception occurred
1236            */
1237            public static int filterCountByC_C_A(long classNameId, long classPK,
1238                    boolean alert)
1239                    throws com.liferay.portal.kernel.exception.SystemException {
1240                    return getPersistence().filterCountByC_C_A(classNameId, classPK, alert);
1241            }
1242    
1243            /**
1244            * Counts all the announcements entries.
1245            *
1246            * @return the number of announcements entries
1247            * @throws SystemException if a system exception occurred
1248            */
1249            public static int countAll()
1250                    throws com.liferay.portal.kernel.exception.SystemException {
1251                    return getPersistence().countAll();
1252            }
1253    
1254            public static AnnouncementsEntryPersistence getPersistence() {
1255                    if (_persistence == null) {
1256                            _persistence = (AnnouncementsEntryPersistence)PortalBeanLocatorUtil.locate(AnnouncementsEntryPersistence.class.getName());
1257    
1258                            ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class,
1259                                    "_persistence");
1260                    }
1261    
1262                    return _persistence;
1263            }
1264    
1265            public void setPersistence(AnnouncementsEntryPersistence persistence) {
1266                    _persistence = persistence;
1267    
1268                    ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class,
1269                            "_persistence");
1270            }
1271    
1272            private static AnnouncementsEntryPersistence _persistence;
1273    }