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