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