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