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