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