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