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