001    /**
002     * Copyright (c) 2000-2012 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            * <p>
253            * 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.
254            * </p>
255            *
256            * @param uuid the uuid
257            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
258            * @return the first matching announcements entry
259            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
260            * @throws SystemException if a system exception occurred
261            */
262            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_First(
263                    java.lang.String uuid,
264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
265                    throws com.liferay.portal.kernel.exception.SystemException,
266                            com.liferay.portlet.announcements.NoSuchEntryException {
267                    return getPersistence().findByUuid_First(uuid, orderByComparator);
268            }
269    
270            /**
271            * Returns the last announcements entry in the ordered set where uuid = &#63;.
272            *
273            * <p>
274            * 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.
275            * </p>
276            *
277            * @param uuid the uuid
278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
279            * @return the last matching announcements entry
280            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
281            * @throws SystemException if a system exception occurred
282            */
283            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUuid_Last(
284                    java.lang.String uuid,
285                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
286                    throws com.liferay.portal.kernel.exception.SystemException,
287                            com.liferay.portlet.announcements.NoSuchEntryException {
288                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
289            }
290    
291            /**
292            * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = &#63;.
293            *
294            * <p>
295            * 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.
296            * </p>
297            *
298            * @param entryId the primary key of the current announcements entry
299            * @param uuid the uuid
300            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
301            * @return the previous, current, and next announcements entry
302            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
303            * @throws SystemException if a system exception occurred
304            */
305            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUuid_PrevAndNext(
306                    long entryId, java.lang.String uuid,
307                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
308                    throws com.liferay.portal.kernel.exception.SystemException,
309                            com.liferay.portlet.announcements.NoSuchEntryException {
310                    return getPersistence()
311                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
312            }
313    
314            /**
315            * Returns all the announcements entries that the user has permission to view where uuid = &#63;.
316            *
317            * @param uuid the uuid
318            * @return the matching announcements entries that the user has permission to view
319            * @throws SystemException if a system exception occurred
320            */
321            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid(
322                    java.lang.String uuid)
323                    throws com.liferay.portal.kernel.exception.SystemException {
324                    return getPersistence().filterFindByUuid(uuid);
325            }
326    
327            /**
328            * Returns a range of all the announcements entries that the user has permission to view where uuid = &#63;.
329            *
330            * <p>
331            * 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.
332            * </p>
333            *
334            * @param uuid the uuid
335            * @param start the lower bound of the range of announcements entries
336            * @param end the upper bound of the range of announcements entries (not inclusive)
337            * @return the range of matching announcements entries that the user has permission to view
338            * @throws SystemException if a system exception occurred
339            */
340            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid(
341                    java.lang.String uuid, int start, int end)
342                    throws com.liferay.portal.kernel.exception.SystemException {
343                    return getPersistence().filterFindByUuid(uuid, start, end);
344            }
345    
346            /**
347            * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = &#63;.
348            *
349            * <p>
350            * 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.
351            * </p>
352            *
353            * @param uuid the uuid
354            * @param start the lower bound of the range of announcements entries
355            * @param end the upper bound of the range of announcements entries (not inclusive)
356            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
357            * @return the ordered range of matching announcements entries that the user has permission to view
358            * @throws SystemException if a system exception occurred
359            */
360            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUuid(
361                    java.lang.String uuid, int start, int end,
362                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
363                    throws com.liferay.portal.kernel.exception.SystemException {
364                    return getPersistence()
365                                       .filterFindByUuid(uuid, start, end, orderByComparator);
366            }
367    
368            /**
369            * 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;.
370            *
371            * @param entryId the primary key of the current announcements entry
372            * @param uuid the uuid
373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
374            * @return the previous, current, and next announcements entry
375            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
376            * @throws SystemException if a system exception occurred
377            */
378            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUuid_PrevAndNext(
379                    long entryId, java.lang.String uuid,
380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
381                    throws com.liferay.portal.kernel.exception.SystemException,
382                            com.liferay.portlet.announcements.NoSuchEntryException {
383                    return getPersistence()
384                                       .filterFindByUuid_PrevAndNext(entryId, uuid,
385                            orderByComparator);
386            }
387    
388            /**
389            * Returns all the announcements entries where userId = &#63;.
390            *
391            * @param userId the user ID
392            * @return the matching announcements entries
393            * @throws SystemException if a system exception occurred
394            */
395            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId(
396                    long userId) throws com.liferay.portal.kernel.exception.SystemException {
397                    return getPersistence().findByUserId(userId);
398            }
399    
400            /**
401            * Returns a range of all the announcements entries where userId = &#63;.
402            *
403            * <p>
404            * 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.
405            * </p>
406            *
407            * @param userId the user ID
408            * @param start the lower bound of the range of announcements entries
409            * @param end the upper bound of the range of announcements entries (not inclusive)
410            * @return the range of 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, int start, int end)
415                    throws com.liferay.portal.kernel.exception.SystemException {
416                    return getPersistence().findByUserId(userId, start, end);
417            }
418    
419            /**
420            * Returns an ordered range of all the announcements entries where userId = &#63;.
421            *
422            * <p>
423            * 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.
424            * </p>
425            *
426            * @param userId the user ID
427            * @param start the lower bound of the range of announcements entries
428            * @param end the upper bound of the range of announcements entries (not inclusive)
429            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
430            * @return the ordered range of matching announcements entries
431            * @throws SystemException if a system exception occurred
432            */
433            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByUserId(
434                    long userId, int start, int end,
435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
436                    throws com.liferay.portal.kernel.exception.SystemException {
437                    return getPersistence()
438                                       .findByUserId(userId, start, end, orderByComparator);
439            }
440    
441            /**
442            * Returns the first announcements entry in the ordered set where userId = &#63;.
443            *
444            * <p>
445            * 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.
446            * </p>
447            *
448            * @param userId the user ID
449            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
450            * @return the first matching announcements entry
451            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
452            * @throws SystemException if a system exception occurred
453            */
454            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_First(
455                    long userId,
456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
457                    throws com.liferay.portal.kernel.exception.SystemException,
458                            com.liferay.portlet.announcements.NoSuchEntryException {
459                    return getPersistence().findByUserId_First(userId, orderByComparator);
460            }
461    
462            /**
463            * Returns the last announcements entry in the ordered set where userId = &#63;.
464            *
465            * <p>
466            * 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.
467            * </p>
468            *
469            * @param userId the user ID
470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
471            * @return the last matching announcements entry
472            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
473            * @throws SystemException if a system exception occurred
474            */
475            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByUserId_Last(
476                    long userId,
477                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
478                    throws com.liferay.portal.kernel.exception.SystemException,
479                            com.liferay.portlet.announcements.NoSuchEntryException {
480                    return getPersistence().findByUserId_Last(userId, orderByComparator);
481            }
482    
483            /**
484            * Returns the announcements entries before and after the current announcements entry in the ordered set where userId = &#63;.
485            *
486            * <p>
487            * 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.
488            * </p>
489            *
490            * @param entryId the primary key of the current announcements entry
491            * @param userId the user ID
492            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
493            * @return the previous, current, and next announcements entry
494            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
495            * @throws SystemException if a system exception occurred
496            */
497            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByUserId_PrevAndNext(
498                    long entryId, long userId,
499                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
500                    throws com.liferay.portal.kernel.exception.SystemException,
501                            com.liferay.portlet.announcements.NoSuchEntryException {
502                    return getPersistence()
503                                       .findByUserId_PrevAndNext(entryId, userId, orderByComparator);
504            }
505    
506            /**
507            * Returns all the announcements entries that the user has permission to view where userId = &#63;.
508            *
509            * @param userId the user ID
510            * @return the matching announcements entries that the user has permission to view
511            * @throws SystemException if a system exception occurred
512            */
513            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId(
514                    long userId) throws com.liferay.portal.kernel.exception.SystemException {
515                    return getPersistence().filterFindByUserId(userId);
516            }
517    
518            /**
519            * Returns a range of all the announcements entries that the user has permission to view where userId = &#63;.
520            *
521            * <p>
522            * 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.
523            * </p>
524            *
525            * @param userId the user ID
526            * @param start the lower bound of the range of announcements entries
527            * @param end the upper bound of the range of announcements entries (not inclusive)
528            * @return the range of matching announcements entries that the user has permission to view
529            * @throws SystemException if a system exception occurred
530            */
531            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId(
532                    long userId, int start, int end)
533                    throws com.liferay.portal.kernel.exception.SystemException {
534                    return getPersistence().filterFindByUserId(userId, start, end);
535            }
536    
537            /**
538            * Returns an ordered range of all the announcements entries that the user has permissions to view where userId = &#63;.
539            *
540            * <p>
541            * 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.
542            * </p>
543            *
544            * @param userId the user ID
545            * @param start the lower bound of the range of announcements entries
546            * @param end the upper bound of the range of announcements entries (not inclusive)
547            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
548            * @return the ordered range of matching announcements entries that the user has permission to view
549            * @throws SystemException if a system exception occurred
550            */
551            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByUserId(
552                    long userId, int start, int end,
553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
554                    throws com.liferay.portal.kernel.exception.SystemException {
555                    return getPersistence()
556                                       .filterFindByUserId(userId, start, end, orderByComparator);
557            }
558    
559            /**
560            * 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;.
561            *
562            * @param entryId the primary key of the current announcements entry
563            * @param userId the user ID
564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
565            * @return the previous, current, and next announcements entry
566            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
567            * @throws SystemException if a system exception occurred
568            */
569            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByUserId_PrevAndNext(
570                    long entryId, long userId,
571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
572                    throws com.liferay.portal.kernel.exception.SystemException,
573                            com.liferay.portlet.announcements.NoSuchEntryException {
574                    return getPersistence()
575                                       .filterFindByUserId_PrevAndNext(entryId, userId,
576                            orderByComparator);
577            }
578    
579            /**
580            * Returns all the announcements entries where classNameId = &#63; and classPK = &#63;.
581            *
582            * @param classNameId the class name ID
583            * @param classPK the class p k
584            * @return the matching announcements entries
585            * @throws SystemException if a system exception occurred
586            */
587            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C(
588                    long classNameId, long classPK)
589                    throws com.liferay.portal.kernel.exception.SystemException {
590                    return getPersistence().findByC_C(classNameId, classPK);
591            }
592    
593            /**
594            * Returns a range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
595            *
596            * <p>
597            * 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.
598            * </p>
599            *
600            * @param classNameId the class name ID
601            * @param classPK the class p k
602            * @param start the lower bound of the range of announcements entries
603            * @param end the upper bound of the range of announcements entries (not inclusive)
604            * @return the range of matching announcements entries
605            * @throws SystemException if a system exception occurred
606            */
607            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C(
608                    long classNameId, long classPK, int start, int end)
609                    throws com.liferay.portal.kernel.exception.SystemException {
610                    return getPersistence().findByC_C(classNameId, classPK, start, end);
611            }
612    
613            /**
614            * Returns an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
615            *
616            * <p>
617            * 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.
618            * </p>
619            *
620            * @param classNameId the class name ID
621            * @param classPK the class p k
622            * @param start the lower bound of the range of announcements entries
623            * @param end the upper bound of the range of announcements entries (not inclusive)
624            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
625            * @return the ordered range of matching announcements entries
626            * @throws SystemException if a system exception occurred
627            */
628            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C(
629                    long classNameId, long classPK, int start, int end,
630                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
631                    throws com.liferay.portal.kernel.exception.SystemException {
632                    return getPersistence()
633                                       .findByC_C(classNameId, classPK, start, end,
634                            orderByComparator);
635            }
636    
637            /**
638            * Returns the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
639            *
640            * <p>
641            * 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.
642            * </p>
643            *
644            * @param classNameId the class name ID
645            * @param classPK the class p k
646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
647            * @return the first matching announcements entry
648            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
649            * @throws SystemException if a system exception occurred
650            */
651            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_First(
652                    long classNameId, long classPK,
653                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
654                    throws com.liferay.portal.kernel.exception.SystemException,
655                            com.liferay.portlet.announcements.NoSuchEntryException {
656                    return getPersistence()
657                                       .findByC_C_First(classNameId, classPK, orderByComparator);
658            }
659    
660            /**
661            * Returns the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
662            *
663            * <p>
664            * 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.
665            * </p>
666            *
667            * @param classNameId the class name ID
668            * @param classPK the class p k
669            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
670            * @return the last matching announcements entry
671            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
672            * @throws SystemException if a system exception occurred
673            */
674            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_Last(
675                    long classNameId, long classPK,
676                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
677                    throws com.liferay.portal.kernel.exception.SystemException,
678                            com.liferay.portlet.announcements.NoSuchEntryException {
679                    return getPersistence()
680                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
681            }
682    
683            /**
684            * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
685            *
686            * <p>
687            * 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.
688            * </p>
689            *
690            * @param entryId the primary key of the current announcements entry
691            * @param classNameId the class name ID
692            * @param classPK the class p k
693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
694            * @return the previous, current, and next announcements entry
695            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
696            * @throws SystemException if a system exception occurred
697            */
698            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_PrevAndNext(
699                    long entryId, long classNameId, long classPK,
700                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
701                    throws com.liferay.portal.kernel.exception.SystemException,
702                            com.liferay.portlet.announcements.NoSuchEntryException {
703                    return getPersistence()
704                                       .findByC_C_PrevAndNext(entryId, classNameId, classPK,
705                            orderByComparator);
706            }
707    
708            /**
709            * Returns all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63;.
710            *
711            * @param classNameId the class name ID
712            * @param classPK the class p k
713            * @return the matching announcements entries that the user has permission to view
714            * @throws SystemException if a system exception occurred
715            */
716            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C(
717                    long classNameId, long classPK)
718                    throws com.liferay.portal.kernel.exception.SystemException {
719                    return getPersistence().filterFindByC_C(classNameId, classPK);
720            }
721    
722            /**
723            * Returns a range of all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63;.
724            *
725            * <p>
726            * 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.
727            * </p>
728            *
729            * @param classNameId the class name ID
730            * @param classPK the class p k
731            * @param start the lower bound of the range of announcements entries
732            * @param end the upper bound of the range of announcements entries (not inclusive)
733            * @return the range of matching announcements entries that the user has permission to view
734            * @throws SystemException if a system exception occurred
735            */
736            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C(
737                    long classNameId, long classPK, int start, int end)
738                    throws com.liferay.portal.kernel.exception.SystemException {
739                    return getPersistence().filterFindByC_C(classNameId, classPK, start, end);
740            }
741    
742            /**
743            * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = &#63; and classPK = &#63;.
744            *
745            * <p>
746            * 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.
747            * </p>
748            *
749            * @param classNameId the class name ID
750            * @param classPK the class p k
751            * @param start the lower bound of the range of announcements entries
752            * @param end the upper bound of the range of announcements entries (not inclusive)
753            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
754            * @return the ordered range of matching announcements entries that the user has permission to view
755            * @throws SystemException if a system exception occurred
756            */
757            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C(
758                    long classNameId, long classPK, int start, int end,
759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
760                    throws com.liferay.portal.kernel.exception.SystemException {
761                    return getPersistence()
762                                       .filterFindByC_C(classNameId, classPK, start, end,
763                            orderByComparator);
764            }
765    
766            /**
767            * 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;.
768            *
769            * @param entryId the primary key of the current announcements entry
770            * @param classNameId the class name ID
771            * @param classPK the class p k
772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
773            * @return the previous, current, and next announcements entry
774            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
775            * @throws SystemException if a system exception occurred
776            */
777            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] filterFindByC_C_PrevAndNext(
778                    long entryId, long classNameId, long classPK,
779                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
780                    throws com.liferay.portal.kernel.exception.SystemException,
781                            com.liferay.portlet.announcements.NoSuchEntryException {
782                    return getPersistence()
783                                       .filterFindByC_C_PrevAndNext(entryId, classNameId, classPK,
784                            orderByComparator);
785            }
786    
787            /**
788            * Returns all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
789            *
790            * @param classNameId the class name ID
791            * @param classPK the class p k
792            * @param alert the alert
793            * @return the matching announcements entries
794            * @throws SystemException if a system exception occurred
795            */
796            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A(
797                    long classNameId, long classPK, boolean alert)
798                    throws com.liferay.portal.kernel.exception.SystemException {
799                    return getPersistence().findByC_C_A(classNameId, classPK, alert);
800            }
801    
802            /**
803            * Returns a range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
804            *
805            * <p>
806            * 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.
807            * </p>
808            *
809            * @param classNameId the class name ID
810            * @param classPK the class p k
811            * @param alert the alert
812            * @param start the lower bound of the range of announcements entries
813            * @param end the upper bound of the range of announcements entries (not inclusive)
814            * @return the range of matching announcements entries
815            * @throws SystemException if a system exception occurred
816            */
817            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A(
818                    long classNameId, long classPK, boolean alert, int start, int end)
819                    throws com.liferay.portal.kernel.exception.SystemException {
820                    return getPersistence()
821                                       .findByC_C_A(classNameId, classPK, alert, start, end);
822            }
823    
824            /**
825            * Returns an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
826            *
827            * <p>
828            * 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.
829            * </p>
830            *
831            * @param classNameId the class name ID
832            * @param classPK the class p k
833            * @param alert the alert
834            * @param start the lower bound of the range of announcements entries
835            * @param end the upper bound of the range of announcements entries (not inclusive)
836            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
837            * @return the ordered range of matching announcements entries
838            * @throws SystemException if a system exception occurred
839            */
840            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findByC_C_A(
841                    long classNameId, long classPK, boolean alert, int start, int end,
842                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
843                    throws com.liferay.portal.kernel.exception.SystemException {
844                    return getPersistence()
845                                       .findByC_C_A(classNameId, classPK, alert, start, end,
846                            orderByComparator);
847            }
848    
849            /**
850            * Returns the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
851            *
852            * <p>
853            * 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.
854            * </p>
855            *
856            * @param classNameId the class name ID
857            * @param classPK the class p k
858            * @param alert the alert
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the first matching announcements entry
861            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
862            * @throws SystemException if a system exception occurred
863            */
864            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_First(
865                    long classNameId, long classPK, boolean alert,
866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
867                    throws com.liferay.portal.kernel.exception.SystemException,
868                            com.liferay.portlet.announcements.NoSuchEntryException {
869                    return getPersistence()
870                                       .findByC_C_A_First(classNameId, classPK, alert,
871                            orderByComparator);
872            }
873    
874            /**
875            * Returns the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
876            *
877            * <p>
878            * 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.
879            * </p>
880            *
881            * @param classNameId the class name ID
882            * @param classPK the class p k
883            * @param alert the alert
884            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
885            * @return the last matching announcements entry
886            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a matching announcements entry could not be found
887            * @throws SystemException if a system exception occurred
888            */
889            public static com.liferay.portlet.announcements.model.AnnouncementsEntry findByC_C_A_Last(
890                    long classNameId, long classPK, boolean alert,
891                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
892                    throws com.liferay.portal.kernel.exception.SystemException,
893                            com.liferay.portlet.announcements.NoSuchEntryException {
894                    return getPersistence()
895                                       .findByC_C_A_Last(classNameId, classPK, alert,
896                            orderByComparator);
897            }
898    
899            /**
900            * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
901            *
902            * <p>
903            * 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.
904            * </p>
905            *
906            * @param entryId the primary key of the current announcements entry
907            * @param classNameId the class name ID
908            * @param classPK the class p k
909            * @param alert the alert
910            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
911            * @return the previous, current, and next announcements entry
912            * @throws com.liferay.portlet.announcements.NoSuchEntryException if a announcements entry with the primary key could not be found
913            * @throws SystemException if a system exception occurred
914            */
915            public static com.liferay.portlet.announcements.model.AnnouncementsEntry[] findByC_C_A_PrevAndNext(
916                    long entryId, long classNameId, long classPK, boolean alert,
917                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
918                    throws com.liferay.portal.kernel.exception.SystemException,
919                            com.liferay.portlet.announcements.NoSuchEntryException {
920                    return getPersistence()
921                                       .findByC_C_A_PrevAndNext(entryId, classNameId, classPK,
922                            alert, orderByComparator);
923            }
924    
925            /**
926            * Returns all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
927            *
928            * @param classNameId the class name ID
929            * @param classPK the class p k
930            * @param alert the alert
931            * @return the matching announcements entries that the user has permission to view
932            * @throws SystemException if a system exception occurred
933            */
934            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A(
935                    long classNameId, long classPK, boolean alert)
936                    throws com.liferay.portal.kernel.exception.SystemException {
937                    return getPersistence().filterFindByC_C_A(classNameId, classPK, alert);
938            }
939    
940            /**
941            * Returns a range of all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
942            *
943            * <p>
944            * 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.
945            * </p>
946            *
947            * @param classNameId the class name ID
948            * @param classPK the class p k
949            * @param alert the alert
950            * @param start the lower bound of the range of announcements entries
951            * @param end the upper bound of the range of announcements entries (not inclusive)
952            * @return the range of matching announcements entries that the user has permission to view
953            * @throws SystemException if a system exception occurred
954            */
955            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A(
956                    long classNameId, long classPK, boolean alert, int start, int end)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    return getPersistence()
959                                       .filterFindByC_C_A(classNameId, classPK, alert, start, end);
960            }
961    
962            /**
963            * 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;.
964            *
965            * <p>
966            * 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.
967            * </p>
968            *
969            * @param classNameId the class name ID
970            * @param classPK the class p k
971            * @param alert the alert
972            * @param start the lower bound of the range of announcements entries
973            * @param end the upper bound of the range of announcements entries (not inclusive)
974            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
975            * @return the ordered range of matching announcements entries that the user has permission to view
976            * @throws SystemException if a system exception occurred
977            */
978            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> filterFindByC_C_A(
979                    long classNameId, long classPK, boolean alert, int start, int end,
980                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
981                    throws com.liferay.portal.kernel.exception.SystemException {
982                    return getPersistence()
983                                       .filterFindByC_C_A(classNameId, classPK, alert, start, end,
984                            orderByComparator);
985            }
986    
987            /**
988            * 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;.
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[] filterFindByC_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                                       .filterFindByC_C_A_PrevAndNext(entryId, classNameId,
1006                            classPK, alert, orderByComparator);
1007            }
1008    
1009            /**
1010            * Returns all the announcements entries.
1011            *
1012            * @return the announcements entries
1013            * @throws SystemException if a system exception occurred
1014            */
1015            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll()
1016                    throws com.liferay.portal.kernel.exception.SystemException {
1017                    return getPersistence().findAll();
1018            }
1019    
1020            /**
1021            * Returns a range of all the announcements entries.
1022            *
1023            * <p>
1024            * 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.
1025            * </p>
1026            *
1027            * @param start the lower bound of the range of announcements entries
1028            * @param end the upper bound of the range of announcements entries (not inclusive)
1029            * @return the range of announcements entries
1030            * @throws SystemException if a system exception occurred
1031            */
1032            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll(
1033                    int start, int end)
1034                    throws com.liferay.portal.kernel.exception.SystemException {
1035                    return getPersistence().findAll(start, end);
1036            }
1037    
1038            /**
1039            * Returns an ordered range of all the announcements entries.
1040            *
1041            * <p>
1042            * 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.
1043            * </p>
1044            *
1045            * @param start the lower bound of the range of announcements entries
1046            * @param end the upper bound of the range of announcements entries (not inclusive)
1047            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1048            * @return the ordered range of announcements entries
1049            * @throws SystemException if a system exception occurred
1050            */
1051            public static java.util.List<com.liferay.portlet.announcements.model.AnnouncementsEntry> findAll(
1052                    int start, int end,
1053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1054                    throws com.liferay.portal.kernel.exception.SystemException {
1055                    return getPersistence().findAll(start, end, orderByComparator);
1056            }
1057    
1058            /**
1059            * Removes all the announcements entries where uuid = &#63; from the database.
1060            *
1061            * @param uuid the uuid
1062            * @throws SystemException if a system exception occurred
1063            */
1064            public static void removeByUuid(java.lang.String uuid)
1065                    throws com.liferay.portal.kernel.exception.SystemException {
1066                    getPersistence().removeByUuid(uuid);
1067            }
1068    
1069            /**
1070            * Removes all the announcements entries where userId = &#63; from the database.
1071            *
1072            * @param userId the user ID
1073            * @throws SystemException if a system exception occurred
1074            */
1075            public static void removeByUserId(long userId)
1076                    throws com.liferay.portal.kernel.exception.SystemException {
1077                    getPersistence().removeByUserId(userId);
1078            }
1079    
1080            /**
1081            * Removes all the announcements entries where classNameId = &#63; and classPK = &#63; from the database.
1082            *
1083            * @param classNameId the class name ID
1084            * @param classPK the class p k
1085            * @throws SystemException if a system exception occurred
1086            */
1087            public static void removeByC_C(long classNameId, long classPK)
1088                    throws com.liferay.portal.kernel.exception.SystemException {
1089                    getPersistence().removeByC_C(classNameId, classPK);
1090            }
1091    
1092            /**
1093            * Removes all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63; from the database.
1094            *
1095            * @param classNameId the class name ID
1096            * @param classPK the class p k
1097            * @param alert the alert
1098            * @throws SystemException if a system exception occurred
1099            */
1100            public static void removeByC_C_A(long classNameId, long classPK,
1101                    boolean alert)
1102                    throws com.liferay.portal.kernel.exception.SystemException {
1103                    getPersistence().removeByC_C_A(classNameId, classPK, alert);
1104            }
1105    
1106            /**
1107            * Removes all the announcements entries from the database.
1108            *
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static void removeAll()
1112                    throws com.liferay.portal.kernel.exception.SystemException {
1113                    getPersistence().removeAll();
1114            }
1115    
1116            /**
1117            * Returns the number of announcements entries where uuid = &#63;.
1118            *
1119            * @param uuid the uuid
1120            * @return the number of matching announcements entries
1121            * @throws SystemException if a system exception occurred
1122            */
1123            public static int countByUuid(java.lang.String uuid)
1124                    throws com.liferay.portal.kernel.exception.SystemException {
1125                    return getPersistence().countByUuid(uuid);
1126            }
1127    
1128            /**
1129            * Returns the number of announcements entries that the user has permission to view where uuid = &#63;.
1130            *
1131            * @param uuid the uuid
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 filterCountByUuid(java.lang.String uuid)
1136                    throws com.liferay.portal.kernel.exception.SystemException {
1137                    return getPersistence().filterCountByUuid(uuid);
1138            }
1139    
1140            /**
1141            * Returns the number of announcements entries where userId = &#63;.
1142            *
1143            * @param userId the user ID
1144            * @return the number of matching announcements entries
1145            * @throws SystemException if a system exception occurred
1146            */
1147            public static int countByUserId(long userId)
1148                    throws com.liferay.portal.kernel.exception.SystemException {
1149                    return getPersistence().countByUserId(userId);
1150            }
1151    
1152            /**
1153            * Returns the number of announcements entries that the user has permission to view where userId = &#63;.
1154            *
1155            * @param userId the user ID
1156            * @return the number of matching announcements entries that the user has permission to view
1157            * @throws SystemException if a system exception occurred
1158            */
1159            public static int filterCountByUserId(long userId)
1160                    throws com.liferay.portal.kernel.exception.SystemException {
1161                    return getPersistence().filterCountByUserId(userId);
1162            }
1163    
1164            /**
1165            * Returns the number of announcements entries where classNameId = &#63; and classPK = &#63;.
1166            *
1167            * @param classNameId the class name ID
1168            * @param classPK the class p k
1169            * @return the number of matching announcements entries
1170            * @throws SystemException if a system exception occurred
1171            */
1172            public static int countByC_C(long classNameId, long classPK)
1173                    throws com.liferay.portal.kernel.exception.SystemException {
1174                    return getPersistence().countByC_C(classNameId, classPK);
1175            }
1176    
1177            /**
1178            * Returns the number of announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63;.
1179            *
1180            * @param classNameId the class name ID
1181            * @param classPK the class p k
1182            * @return the number of matching announcements entries that the user has permission to view
1183            * @throws SystemException if a system exception occurred
1184            */
1185            public static int filterCountByC_C(long classNameId, long classPK)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence().filterCountByC_C(classNameId, classPK);
1188            }
1189    
1190            /**
1191            * Returns the number of announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
1192            *
1193            * @param classNameId the class name ID
1194            * @param classPK the class p k
1195            * @param alert the alert
1196            * @return the number of matching announcements entries
1197            * @throws SystemException if a system exception occurred
1198            */
1199            public static int countByC_C_A(long classNameId, long classPK, boolean alert)
1200                    throws com.liferay.portal.kernel.exception.SystemException {
1201                    return getPersistence().countByC_C_A(classNameId, classPK, alert);
1202            }
1203    
1204            /**
1205            * Returns the number of announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
1206            *
1207            * @param classNameId the class name ID
1208            * @param classPK the class p k
1209            * @param alert the alert
1210            * @return the number of matching announcements entries that the user has permission to view
1211            * @throws SystemException if a system exception occurred
1212            */
1213            public static int filterCountByC_C_A(long classNameId, long classPK,
1214                    boolean alert)
1215                    throws com.liferay.portal.kernel.exception.SystemException {
1216                    return getPersistence().filterCountByC_C_A(classNameId, classPK, alert);
1217            }
1218    
1219            /**
1220            * Returns the number of announcements entries.
1221            *
1222            * @return the number of announcements entries
1223            * @throws SystemException if a system exception occurred
1224            */
1225            public static int countAll()
1226                    throws com.liferay.portal.kernel.exception.SystemException {
1227                    return getPersistence().countAll();
1228            }
1229    
1230            public static AnnouncementsEntryPersistence getPersistence() {
1231                    if (_persistence == null) {
1232                            _persistence = (AnnouncementsEntryPersistence)PortalBeanLocatorUtil.locate(AnnouncementsEntryPersistence.class.getName());
1233    
1234                            ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class,
1235                                    "_persistence");
1236                    }
1237    
1238                    return _persistence;
1239            }
1240    
1241            public void setPersistence(AnnouncementsEntryPersistence persistence) {
1242                    _persistence = persistence;
1243    
1244                    ReferenceRegistry.registerReference(AnnouncementsEntryUtil.class,
1245                            "_persistence");
1246            }
1247    
1248            private static AnnouncementsEntryPersistence _persistence;
1249    }