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