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