001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.announcements.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.announcements.model.AnnouncementsEntry;
022    
023    /**
024     * The persistence interface for the announcements entry service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.announcements.service.persistence.impl.AnnouncementsEntryPersistenceImpl
032     * @see AnnouncementsEntryUtil
033     * @generated
034     */
035    @ProviderType
036    public interface AnnouncementsEntryPersistence extends BasePersistence<AnnouncementsEntry> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link AnnouncementsEntryUtil} to access the announcements entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the announcements entries where uuid = &#63;.
045            *
046            * @param uuid the uuid
047            * @return the matching announcements entries
048            */
049            public java.util.List<AnnouncementsEntry> findByUuid(java.lang.String uuid);
050    
051            /**
052            * Returns a range of all the announcements entries where uuid = &#63;.
053            *
054            * <p>
055            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
056            * </p>
057            *
058            * @param uuid the uuid
059            * @param start the lower bound of the range of announcements entries
060            * @param end the upper bound of the range of announcements entries (not inclusive)
061            * @return the range of matching announcements entries
062            */
063            public java.util.List<AnnouncementsEntry> findByUuid(
064                    java.lang.String uuid, int start, int end);
065    
066            /**
067            * Returns an ordered range of all the announcements entries where uuid = &#63;.
068            *
069            * <p>
070            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
071            * </p>
072            *
073            * @param uuid the uuid
074            * @param start the lower bound of the range of announcements entries
075            * @param end the upper bound of the range of announcements entries (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching announcements entries
078            */
079            public java.util.List<AnnouncementsEntry> findByUuid(
080                    java.lang.String uuid, int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
082    
083            /**
084            * Returns the first announcements entry in the ordered set where uuid = &#63;.
085            *
086            * @param uuid the uuid
087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
088            * @return the first matching announcements entry
089            * @throws NoSuchEntryException if a matching announcements entry could not be found
090            */
091            public AnnouncementsEntry findByUuid_First(java.lang.String uuid,
092                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
093                    throws com.liferay.portlet.announcements.NoSuchEntryException;
094    
095            /**
096            * Returns the first announcements entry in the ordered set where uuid = &#63;.
097            *
098            * @param uuid the uuid
099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
100            * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
101            */
102            public AnnouncementsEntry fetchByUuid_First(java.lang.String uuid,
103                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
104    
105            /**
106            * Returns the last announcements entry in the ordered set where uuid = &#63;.
107            *
108            * @param uuid the uuid
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the last matching announcements entry
111            * @throws NoSuchEntryException if a matching announcements entry could not be found
112            */
113            public AnnouncementsEntry findByUuid_Last(java.lang.String uuid,
114                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
115                    throws com.liferay.portlet.announcements.NoSuchEntryException;
116    
117            /**
118            * Returns the last announcements entry in the ordered set where uuid = &#63;.
119            *
120            * @param uuid the uuid
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
123            */
124            public AnnouncementsEntry fetchByUuid_Last(java.lang.String uuid,
125                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
126    
127            /**
128            * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = &#63;.
129            *
130            * @param entryId the primary key of the current announcements entry
131            * @param uuid the uuid
132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
133            * @return the previous, current, and next announcements entry
134            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
135            */
136            public AnnouncementsEntry[] findByUuid_PrevAndNext(long entryId,
137                    java.lang.String uuid,
138                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
139                    throws com.liferay.portlet.announcements.NoSuchEntryException;
140    
141            /**
142            * Returns all the announcements entries that the user has permission to view where uuid = &#63;.
143            *
144            * @param uuid the uuid
145            * @return the matching announcements entries that the user has permission to view
146            */
147            public java.util.List<AnnouncementsEntry> filterFindByUuid(
148                    java.lang.String uuid);
149    
150            /**
151            * Returns a range of all the announcements entries that the user has permission to view where uuid = &#63;.
152            *
153            * <p>
154            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
155            * </p>
156            *
157            * @param uuid the uuid
158            * @param start the lower bound of the range of announcements entries
159            * @param end the upper bound of the range of announcements entries (not inclusive)
160            * @return the range of matching announcements entries that the user has permission to view
161            */
162            public java.util.List<AnnouncementsEntry> filterFindByUuid(
163                    java.lang.String uuid, int start, int end);
164    
165            /**
166            * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = &#63;.
167            *
168            * <p>
169            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
170            * </p>
171            *
172            * @param uuid the uuid
173            * @param start the lower bound of the range of announcements entries
174            * @param end the upper bound of the range of announcements entries (not inclusive)
175            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
176            * @return the ordered range of matching announcements entries that the user has permission to view
177            */
178            public java.util.List<AnnouncementsEntry> filterFindByUuid(
179                    java.lang.String uuid, int start, int end,
180                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
181    
182            /**
183            * 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;.
184            *
185            * @param entryId the primary key of the current announcements entry
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the previous, current, and next announcements entry
189            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
190            */
191            public AnnouncementsEntry[] filterFindByUuid_PrevAndNext(long entryId,
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
194                    throws com.liferay.portlet.announcements.NoSuchEntryException;
195    
196            /**
197            * Removes all the announcements entries where uuid = &#63; from the database.
198            *
199            * @param uuid the uuid
200            */
201            public void removeByUuid(java.lang.String uuid);
202    
203            /**
204            * Returns the number of announcements entries where uuid = &#63;.
205            *
206            * @param uuid the uuid
207            * @return the number of matching announcements entries
208            */
209            public int countByUuid(java.lang.String uuid);
210    
211            /**
212            * Returns the number of announcements entries that the user has permission to view where uuid = &#63;.
213            *
214            * @param uuid the uuid
215            * @return the number of matching announcements entries that the user has permission to view
216            */
217            public int filterCountByUuid(java.lang.String uuid);
218    
219            /**
220            * Returns all the announcements entries where uuid = &#63; and companyId = &#63;.
221            *
222            * @param uuid the uuid
223            * @param companyId the company ID
224            * @return the matching announcements entries
225            */
226            public java.util.List<AnnouncementsEntry> findByUuid_C(
227                    java.lang.String uuid, long companyId);
228    
229            /**
230            * Returns a range of all the announcements entries where uuid = &#63; and companyId = &#63;.
231            *
232            * <p>
233            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
234            * </p>
235            *
236            * @param uuid the uuid
237            * @param companyId the company ID
238            * @param start the lower bound of the range of announcements entries
239            * @param end the upper bound of the range of announcements entries (not inclusive)
240            * @return the range of matching announcements entries
241            */
242            public java.util.List<AnnouncementsEntry> findByUuid_C(
243                    java.lang.String uuid, long companyId, int start, int end);
244    
245            /**
246            * Returns an ordered range of all the announcements entries where uuid = &#63; and companyId = &#63;.
247            *
248            * <p>
249            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
250            * </p>
251            *
252            * @param uuid the uuid
253            * @param companyId the company ID
254            * @param start the lower bound of the range of announcements entries
255            * @param end the upper bound of the range of announcements entries (not inclusive)
256            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
257            * @return the ordered range of matching announcements entries
258            */
259            public java.util.List<AnnouncementsEntry> findByUuid_C(
260                    java.lang.String uuid, long companyId, int start, int end,
261                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
262    
263            /**
264            * Returns the first announcements entry in the ordered set where uuid = &#63; and companyId = &#63;.
265            *
266            * @param uuid the uuid
267            * @param companyId the company ID
268            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
269            * @return the first matching announcements entry
270            * @throws NoSuchEntryException if a matching announcements entry could not be found
271            */
272            public AnnouncementsEntry findByUuid_C_First(java.lang.String uuid,
273                    long companyId,
274                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
275                    throws com.liferay.portlet.announcements.NoSuchEntryException;
276    
277            /**
278            * Returns the first announcements entry in the ordered set where uuid = &#63; and companyId = &#63;.
279            *
280            * @param uuid the uuid
281            * @param companyId the company ID
282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
283            * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
284            */
285            public AnnouncementsEntry fetchByUuid_C_First(java.lang.String uuid,
286                    long companyId,
287                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
288    
289            /**
290            * Returns the last announcements entry in the ordered set where uuid = &#63; and companyId = &#63;.
291            *
292            * @param uuid the uuid
293            * @param companyId the company ID
294            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
295            * @return the last matching announcements entry
296            * @throws NoSuchEntryException if a matching announcements entry could not be found
297            */
298            public AnnouncementsEntry findByUuid_C_Last(java.lang.String uuid,
299                    long companyId,
300                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
301                    throws com.liferay.portlet.announcements.NoSuchEntryException;
302    
303            /**
304            * Returns the last announcements entry in the ordered set where uuid = &#63; and companyId = &#63;.
305            *
306            * @param uuid the uuid
307            * @param companyId the company ID
308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
309            * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
310            */
311            public AnnouncementsEntry fetchByUuid_C_Last(java.lang.String uuid,
312                    long companyId,
313                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
314    
315            /**
316            * Returns the announcements entries before and after the current announcements entry in the ordered set where uuid = &#63; and companyId = &#63;.
317            *
318            * @param entryId the primary key of the current announcements entry
319            * @param uuid the uuid
320            * @param companyId the company ID
321            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
322            * @return the previous, current, and next announcements entry
323            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
324            */
325            public AnnouncementsEntry[] findByUuid_C_PrevAndNext(long entryId,
326                    java.lang.String uuid, long companyId,
327                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
328                    throws com.liferay.portlet.announcements.NoSuchEntryException;
329    
330            /**
331            * Returns all the announcements entries that the user has permission to view where uuid = &#63; and companyId = &#63;.
332            *
333            * @param uuid the uuid
334            * @param companyId the company ID
335            * @return the matching announcements entries that the user has permission to view
336            */
337            public java.util.List<AnnouncementsEntry> filterFindByUuid_C(
338                    java.lang.String uuid, long companyId);
339    
340            /**
341            * Returns a range of all the announcements entries that the user has permission to view where uuid = &#63; and companyId = &#63;.
342            *
343            * <p>
344            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
345            * </p>
346            *
347            * @param uuid the uuid
348            * @param companyId the company ID
349            * @param start the lower bound of the range of announcements entries
350            * @param end the upper bound of the range of announcements entries (not inclusive)
351            * @return the range of matching announcements entries that the user has permission to view
352            */
353            public java.util.List<AnnouncementsEntry> filterFindByUuid_C(
354                    java.lang.String uuid, long companyId, int start, int end);
355    
356            /**
357            * Returns an ordered range of all the announcements entries that the user has permissions to view where uuid = &#63; and companyId = &#63;.
358            *
359            * <p>
360            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
361            * </p>
362            *
363            * @param uuid the uuid
364            * @param companyId the company ID
365            * @param start the lower bound of the range of announcements entries
366            * @param end the upper bound of the range of announcements entries (not inclusive)
367            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
368            * @return the ordered range of matching announcements entries that the user has permission to view
369            */
370            public java.util.List<AnnouncementsEntry> filterFindByUuid_C(
371                    java.lang.String uuid, long companyId, int start, int end,
372                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
373    
374            /**
375            * 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;.
376            *
377            * @param entryId the primary key of the current announcements entry
378            * @param uuid the uuid
379            * @param companyId the company ID
380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
381            * @return the previous, current, and next announcements entry
382            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
383            */
384            public AnnouncementsEntry[] filterFindByUuid_C_PrevAndNext(long entryId,
385                    java.lang.String uuid, long companyId,
386                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
387                    throws com.liferay.portlet.announcements.NoSuchEntryException;
388    
389            /**
390            * Removes all the announcements entries where uuid = &#63; and companyId = &#63; from the database.
391            *
392            * @param uuid the uuid
393            * @param companyId the company ID
394            */
395            public void removeByUuid_C(java.lang.String uuid, long companyId);
396    
397            /**
398            * Returns the number of announcements entries where uuid = &#63; and companyId = &#63;.
399            *
400            * @param uuid the uuid
401            * @param companyId the company ID
402            * @return the number of matching announcements entries
403            */
404            public int countByUuid_C(java.lang.String uuid, long companyId);
405    
406            /**
407            * Returns the number of announcements entries that the user has permission to view where uuid = &#63; and companyId = &#63;.
408            *
409            * @param uuid the uuid
410            * @param companyId the company ID
411            * @return the number of matching announcements entries that the user has permission to view
412            */
413            public int filterCountByUuid_C(java.lang.String uuid, long companyId);
414    
415            /**
416            * Returns all the announcements entries where userId = &#63;.
417            *
418            * @param userId the user ID
419            * @return the matching announcements entries
420            */
421            public java.util.List<AnnouncementsEntry> findByUserId(long userId);
422    
423            /**
424            * Returns a range of all the announcements entries where userId = &#63;.
425            *
426            * <p>
427            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
428            * </p>
429            *
430            * @param userId the user ID
431            * @param start the lower bound of the range of announcements entries
432            * @param end the upper bound of the range of announcements entries (not inclusive)
433            * @return the range of matching announcements entries
434            */
435            public java.util.List<AnnouncementsEntry> findByUserId(long userId,
436                    int start, int end);
437    
438            /**
439            * Returns an ordered range of all the announcements entries where userId = &#63;.
440            *
441            * <p>
442            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
443            * </p>
444            *
445            * @param userId the user ID
446            * @param start the lower bound of the range of announcements entries
447            * @param end the upper bound of the range of announcements entries (not inclusive)
448            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
449            * @return the ordered range of matching announcements entries
450            */
451            public java.util.List<AnnouncementsEntry> findByUserId(long userId,
452                    int start, int end,
453                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
454    
455            /**
456            * Returns the first announcements entry in the ordered set where userId = &#63;.
457            *
458            * @param userId the user ID
459            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
460            * @return the first matching announcements entry
461            * @throws NoSuchEntryException if a matching announcements entry could not be found
462            */
463            public AnnouncementsEntry findByUserId_First(long userId,
464                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
465                    throws com.liferay.portlet.announcements.NoSuchEntryException;
466    
467            /**
468            * Returns the first announcements entry in the ordered set where userId = &#63;.
469            *
470            * @param userId the user ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
473            */
474            public AnnouncementsEntry fetchByUserId_First(long userId,
475                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
476    
477            /**
478            * Returns the last announcements entry in the ordered set where userId = &#63;.
479            *
480            * @param userId the user ID
481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
482            * @return the last matching announcements entry
483            * @throws NoSuchEntryException if a matching announcements entry could not be found
484            */
485            public AnnouncementsEntry findByUserId_Last(long userId,
486                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
487                    throws com.liferay.portlet.announcements.NoSuchEntryException;
488    
489            /**
490            * Returns the last announcements entry in the ordered set where userId = &#63;.
491            *
492            * @param userId the user ID
493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
494            * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
495            */
496            public AnnouncementsEntry fetchByUserId_Last(long userId,
497                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
498    
499            /**
500            * Returns the announcements entries before and after the current announcements entry in the ordered set where userId = &#63;.
501            *
502            * @param entryId the primary key of the current announcements entry
503            * @param userId the user ID
504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
505            * @return the previous, current, and next announcements entry
506            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
507            */
508            public AnnouncementsEntry[] findByUserId_PrevAndNext(long entryId,
509                    long userId,
510                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
511                    throws com.liferay.portlet.announcements.NoSuchEntryException;
512    
513            /**
514            * Returns all the announcements entries that the user has permission to view where userId = &#63;.
515            *
516            * @param userId the user ID
517            * @return the matching announcements entries that the user has permission to view
518            */
519            public java.util.List<AnnouncementsEntry> filterFindByUserId(long userId);
520    
521            /**
522            * Returns a range of all the announcements entries that the user has permission to view where userId = &#63;.
523            *
524            * <p>
525            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
526            * </p>
527            *
528            * @param userId the user ID
529            * @param start the lower bound of the range of announcements entries
530            * @param end the upper bound of the range of announcements entries (not inclusive)
531            * @return the range of matching announcements entries that the user has permission to view
532            */
533            public java.util.List<AnnouncementsEntry> filterFindByUserId(long userId,
534                    int start, int end);
535    
536            /**
537            * Returns an ordered range of all the announcements entries that the user has permissions to view where userId = &#63;.
538            *
539            * <p>
540            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
541            * </p>
542            *
543            * @param userId the user ID
544            * @param start the lower bound of the range of announcements entries
545            * @param end the upper bound of the range of announcements entries (not inclusive)
546            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
547            * @return the ordered range of matching announcements entries that the user has permission to view
548            */
549            public java.util.List<AnnouncementsEntry> filterFindByUserId(long userId,
550                    int start, int end,
551                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
552    
553            /**
554            * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where userId = &#63;.
555            *
556            * @param entryId the primary key of the current announcements entry
557            * @param userId the user ID
558            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
559            * @return the previous, current, and next announcements entry
560            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
561            */
562            public AnnouncementsEntry[] filterFindByUserId_PrevAndNext(long entryId,
563                    long userId,
564                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
565                    throws com.liferay.portlet.announcements.NoSuchEntryException;
566    
567            /**
568            * Removes all the announcements entries where userId = &#63; from the database.
569            *
570            * @param userId the user ID
571            */
572            public void removeByUserId(long userId);
573    
574            /**
575            * Returns the number of announcements entries where userId = &#63;.
576            *
577            * @param userId the user ID
578            * @return the number of matching announcements entries
579            */
580            public int countByUserId(long userId);
581    
582            /**
583            * Returns the number of announcements entries that the user has permission to view where userId = &#63;.
584            *
585            * @param userId the user ID
586            * @return the number of matching announcements entries that the user has permission to view
587            */
588            public int filterCountByUserId(long userId);
589    
590            /**
591            * Returns all the announcements entries where classNameId = &#63; and classPK = &#63;.
592            *
593            * @param classNameId the class name ID
594            * @param classPK the class p k
595            * @return the matching announcements entries
596            */
597            public java.util.List<AnnouncementsEntry> findByC_C(long classNameId,
598                    long classPK);
599    
600            /**
601            * Returns a range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
602            *
603            * <p>
604            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
605            * </p>
606            *
607            * @param classNameId the class name ID
608            * @param classPK the class p k
609            * @param start the lower bound of the range of announcements entries
610            * @param end the upper bound of the range of announcements entries (not inclusive)
611            * @return the range of matching announcements entries
612            */
613            public java.util.List<AnnouncementsEntry> findByC_C(long classNameId,
614                    long classPK, int start, int end);
615    
616            /**
617            * Returns an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63;.
618            *
619            * <p>
620            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
621            * </p>
622            *
623            * @param classNameId the class name ID
624            * @param classPK the class p k
625            * @param start the lower bound of the range of announcements entries
626            * @param end the upper bound of the range of announcements entries (not inclusive)
627            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
628            * @return the ordered range of matching announcements entries
629            */
630            public java.util.List<AnnouncementsEntry> findByC_C(long classNameId,
631                    long classPK, int start, int end,
632                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
633    
634            /**
635            * Returns the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
636            *
637            * @param classNameId the class name ID
638            * @param classPK the class p k
639            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
640            * @return the first matching announcements entry
641            * @throws NoSuchEntryException if a matching announcements entry could not be found
642            */
643            public AnnouncementsEntry findByC_C_First(long classNameId, long classPK,
644                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
645                    throws com.liferay.portlet.announcements.NoSuchEntryException;
646    
647            /**
648            * Returns the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
649            *
650            * @param classNameId the class name ID
651            * @param classPK the class p k
652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
653            * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
654            */
655            public AnnouncementsEntry fetchByC_C_First(long classNameId, long classPK,
656                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
657    
658            /**
659            * Returns the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
660            *
661            * @param classNameId the class name ID
662            * @param classPK the class p k
663            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
664            * @return the last matching announcements entry
665            * @throws NoSuchEntryException if a matching announcements entry could not be found
666            */
667            public AnnouncementsEntry findByC_C_Last(long classNameId, long classPK,
668                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
669                    throws com.liferay.portlet.announcements.NoSuchEntryException;
670    
671            /**
672            * Returns the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
673            *
674            * @param classNameId the class name ID
675            * @param classPK the class p k
676            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
677            * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
678            */
679            public AnnouncementsEntry fetchByC_C_Last(long classNameId, long classPK,
680                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
681    
682            /**
683            * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63;.
684            *
685            * @param entryId the primary key of the current announcements entry
686            * @param classNameId the class name ID
687            * @param classPK the class p k
688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
689            * @return the previous, current, and next announcements entry
690            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
691            */
692            public AnnouncementsEntry[] findByC_C_PrevAndNext(long entryId,
693                    long classNameId, long classPK,
694                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
695                    throws com.liferay.portlet.announcements.NoSuchEntryException;
696    
697            /**
698            * Returns all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63;.
699            *
700            * @param classNameId the class name ID
701            * @param classPK the class p k
702            * @return the matching announcements entries that the user has permission to view
703            */
704            public java.util.List<AnnouncementsEntry> filterFindByC_C(
705                    long classNameId, long classPK);
706    
707            /**
708            * Returns a range of all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63;.
709            *
710            * <p>
711            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
712            * </p>
713            *
714            * @param classNameId the class name ID
715            * @param classPK the class p k
716            * @param start the lower bound of the range of announcements entries
717            * @param end the upper bound of the range of announcements entries (not inclusive)
718            * @return the range of matching announcements entries that the user has permission to view
719            */
720            public java.util.List<AnnouncementsEntry> filterFindByC_C(
721                    long classNameId, long classPK, int start, int end);
722    
723            /**
724            * Returns an ordered range of all the announcements entries that the user has permissions to view where classNameId = &#63; and classPK = &#63;.
725            *
726            * <p>
727            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
728            * </p>
729            *
730            * @param classNameId the class name ID
731            * @param classPK the class p k
732            * @param start the lower bound of the range of announcements entries
733            * @param end the upper bound of the range of announcements entries (not inclusive)
734            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
735            * @return the ordered range of matching announcements entries that the user has permission to view
736            */
737            public java.util.List<AnnouncementsEntry> filterFindByC_C(
738                    long classNameId, long classPK, int start, int end,
739                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
740    
741            /**
742            * 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;.
743            *
744            * @param entryId the primary key of the current announcements entry
745            * @param classNameId the class name ID
746            * @param classPK the class p k
747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
748            * @return the previous, current, and next announcements entry
749            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
750            */
751            public AnnouncementsEntry[] filterFindByC_C_PrevAndNext(long entryId,
752                    long classNameId, long classPK,
753                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
754                    throws com.liferay.portlet.announcements.NoSuchEntryException;
755    
756            /**
757            * Removes all the announcements entries where classNameId = &#63; and classPK = &#63; from the database.
758            *
759            * @param classNameId the class name ID
760            * @param classPK the class p k
761            */
762            public void removeByC_C(long classNameId, long classPK);
763    
764            /**
765            * Returns the number of announcements entries where classNameId = &#63; and classPK = &#63;.
766            *
767            * @param classNameId the class name ID
768            * @param classPK the class p k
769            * @return the number of matching announcements entries
770            */
771            public int countByC_C(long classNameId, long classPK);
772    
773            /**
774            * Returns the number of announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63;.
775            *
776            * @param classNameId the class name ID
777            * @param classPK the class p k
778            * @return the number of matching announcements entries that the user has permission to view
779            */
780            public int filterCountByC_C(long classNameId, long classPK);
781    
782            /**
783            * Returns all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
784            *
785            * @param classNameId the class name ID
786            * @param classPK the class p k
787            * @param alert the alert
788            * @return the matching announcements entries
789            */
790            public java.util.List<AnnouncementsEntry> findByC_C_A(long classNameId,
791                    long classPK, boolean alert);
792    
793            /**
794            * Returns a range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
798            * </p>
799            *
800            * @param classNameId the class name ID
801            * @param classPK the class p k
802            * @param alert the alert
803            * @param start the lower bound of the range of announcements entries
804            * @param end the upper bound of the range of announcements entries (not inclusive)
805            * @return the range of matching announcements entries
806            */
807            public java.util.List<AnnouncementsEntry> findByC_C_A(long classNameId,
808                    long classPK, boolean alert, int start, int end);
809    
810            /**
811            * Returns an ordered range of all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
812            *
813            * <p>
814            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
815            * </p>
816            *
817            * @param classNameId the class name ID
818            * @param classPK the class p k
819            * @param alert the alert
820            * @param start the lower bound of the range of announcements entries
821            * @param end the upper bound of the range of announcements entries (not inclusive)
822            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
823            * @return the ordered range of matching announcements entries
824            */
825            public java.util.List<AnnouncementsEntry> findByC_C_A(long classNameId,
826                    long classPK, boolean alert, int start, int end,
827                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
828    
829            /**
830            * Returns the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
831            *
832            * @param classNameId the class name ID
833            * @param classPK the class p k
834            * @param alert the alert
835            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
836            * @return the first matching announcements entry
837            * @throws NoSuchEntryException if a matching announcements entry could not be found
838            */
839            public AnnouncementsEntry findByC_C_A_First(long classNameId, long classPK,
840                    boolean alert,
841                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
842                    throws com.liferay.portlet.announcements.NoSuchEntryException;
843    
844            /**
845            * Returns the first announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
846            *
847            * @param classNameId the class name ID
848            * @param classPK the class p k
849            * @param alert the alert
850            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
851            * @return the first matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
852            */
853            public AnnouncementsEntry fetchByC_C_A_First(long classNameId,
854                    long classPK, boolean alert,
855                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
856    
857            /**
858            * Returns the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
859            *
860            * @param classNameId the class name ID
861            * @param classPK the class p k
862            * @param alert the alert
863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
864            * @return the last matching announcements entry
865            * @throws NoSuchEntryException if a matching announcements entry could not be found
866            */
867            public AnnouncementsEntry findByC_C_A_Last(long classNameId, long classPK,
868                    boolean alert,
869                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
870                    throws com.liferay.portlet.announcements.NoSuchEntryException;
871    
872            /**
873            * Returns the last announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
874            *
875            * @param classNameId the class name ID
876            * @param classPK the class p k
877            * @param alert the alert
878            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
879            * @return the last matching announcements entry, or <code>null</code> if a matching announcements entry could not be found
880            */
881            public AnnouncementsEntry fetchByC_C_A_Last(long classNameId, long classPK,
882                    boolean alert,
883                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
884    
885            /**
886            * Returns the announcements entries before and after the current announcements entry in the ordered set where classNameId = &#63; and classPK = &#63; and alert = &#63;.
887            *
888            * @param entryId the primary key of the current announcements entry
889            * @param classNameId the class name ID
890            * @param classPK the class p k
891            * @param alert the alert
892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
893            * @return the previous, current, and next announcements entry
894            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
895            */
896            public AnnouncementsEntry[] findByC_C_A_PrevAndNext(long entryId,
897                    long classNameId, long classPK, boolean alert,
898                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
899                    throws com.liferay.portlet.announcements.NoSuchEntryException;
900    
901            /**
902            * Returns all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
903            *
904            * @param classNameId the class name ID
905            * @param classPK the class p k
906            * @param alert the alert
907            * @return the matching announcements entries that the user has permission to view
908            */
909            public java.util.List<AnnouncementsEntry> filterFindByC_C_A(
910                    long classNameId, long classPK, boolean alert);
911    
912            /**
913            * Returns a range of all the announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
914            *
915            * <p>
916            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
917            * </p>
918            *
919            * @param classNameId the class name ID
920            * @param classPK the class p k
921            * @param alert the alert
922            * @param start the lower bound of the range of announcements entries
923            * @param end the upper bound of the range of announcements entries (not inclusive)
924            * @return the range of matching announcements entries that the user has permission to view
925            */
926            public java.util.List<AnnouncementsEntry> filterFindByC_C_A(
927                    long classNameId, long classPK, boolean alert, int start, int end);
928    
929            /**
930            * 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;.
931            *
932            * <p>
933            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
934            * </p>
935            *
936            * @param classNameId the class name ID
937            * @param classPK the class p k
938            * @param alert the alert
939            * @param start the lower bound of the range of announcements entries
940            * @param end the upper bound of the range of announcements entries (not inclusive)
941            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
942            * @return the ordered range of matching announcements entries that the user has permission to view
943            */
944            public java.util.List<AnnouncementsEntry> filterFindByC_C_A(
945                    long classNameId, long classPK, boolean alert, int start, int end,
946                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
947    
948            /**
949            * Returns the announcements entries before and after the current announcements entry in the ordered set of announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
950            *
951            * @param entryId the primary key of the current announcements entry
952            * @param classNameId the class name ID
953            * @param classPK the class p k
954            * @param alert the alert
955            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
956            * @return the previous, current, and next announcements entry
957            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
958            */
959            public AnnouncementsEntry[] filterFindByC_C_A_PrevAndNext(long entryId,
960                    long classNameId, long classPK, boolean alert,
961                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator)
962                    throws com.liferay.portlet.announcements.NoSuchEntryException;
963    
964            /**
965            * Removes all the announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63; from the database.
966            *
967            * @param classNameId the class name ID
968            * @param classPK the class p k
969            * @param alert the alert
970            */
971            public void removeByC_C_A(long classNameId, long classPK, boolean alert);
972    
973            /**
974            * Returns the number of announcements entries where classNameId = &#63; and classPK = &#63; and alert = &#63;.
975            *
976            * @param classNameId the class name ID
977            * @param classPK the class p k
978            * @param alert the alert
979            * @return the number of matching announcements entries
980            */
981            public int countByC_C_A(long classNameId, long classPK, boolean alert);
982    
983            /**
984            * Returns the number of announcements entries that the user has permission to view where classNameId = &#63; and classPK = &#63; and alert = &#63;.
985            *
986            * @param classNameId the class name ID
987            * @param classPK the class p k
988            * @param alert the alert
989            * @return the number of matching announcements entries that the user has permission to view
990            */
991            public int filterCountByC_C_A(long classNameId, long classPK, boolean alert);
992    
993            /**
994            * Caches the announcements entry in the entity cache if it is enabled.
995            *
996            * @param announcementsEntry the announcements entry
997            */
998            public void cacheResult(AnnouncementsEntry announcementsEntry);
999    
1000            /**
1001            * Caches the announcements entries in the entity cache if it is enabled.
1002            *
1003            * @param announcementsEntries the announcements entries
1004            */
1005            public void cacheResult(
1006                    java.util.List<AnnouncementsEntry> announcementsEntries);
1007    
1008            /**
1009            * Creates a new announcements entry with the primary key. Does not add the announcements entry to the database.
1010            *
1011            * @param entryId the primary key for the new announcements entry
1012            * @return the new announcements entry
1013            */
1014            public AnnouncementsEntry create(long entryId);
1015    
1016            /**
1017            * Removes the announcements entry with the primary key from the database. Also notifies the appropriate model listeners.
1018            *
1019            * @param entryId the primary key of the announcements entry
1020            * @return the announcements entry that was removed
1021            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
1022            */
1023            public AnnouncementsEntry remove(long entryId)
1024                    throws com.liferay.portlet.announcements.NoSuchEntryException;
1025    
1026            public AnnouncementsEntry updateImpl(AnnouncementsEntry announcementsEntry);
1027    
1028            /**
1029            * Returns the announcements entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found.
1030            *
1031            * @param entryId the primary key of the announcements entry
1032            * @return the announcements entry
1033            * @throws NoSuchEntryException if a announcements entry with the primary key could not be found
1034            */
1035            public AnnouncementsEntry findByPrimaryKey(long entryId)
1036                    throws com.liferay.portlet.announcements.NoSuchEntryException;
1037    
1038            /**
1039            * Returns the announcements entry with the primary key or returns <code>null</code> if it could not be found.
1040            *
1041            * @param entryId the primary key of the announcements entry
1042            * @return the announcements entry, or <code>null</code> if a announcements entry with the primary key could not be found
1043            */
1044            public AnnouncementsEntry fetchByPrimaryKey(long entryId);
1045    
1046            @Override
1047            public java.util.Map<java.io.Serializable, AnnouncementsEntry> fetchByPrimaryKeys(
1048                    java.util.Set<java.io.Serializable> primaryKeys);
1049    
1050            /**
1051            * Returns all the announcements entries.
1052            *
1053            * @return the announcements entries
1054            */
1055            public java.util.List<AnnouncementsEntry> findAll();
1056    
1057            /**
1058            * Returns a range of all the announcements entries.
1059            *
1060            * <p>
1061            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1062            * </p>
1063            *
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            * @return the range of announcements entries
1067            */
1068            public java.util.List<AnnouncementsEntry> findAll(int start, int end);
1069    
1070            /**
1071            * Returns an ordered range of all the announcements entries.
1072            *
1073            * <p>
1074            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AnnouncementsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1075            * </p>
1076            *
1077            * @param start the lower bound of the range of announcements entries
1078            * @param end the upper bound of the range of announcements entries (not inclusive)
1079            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1080            * @return the ordered range of announcements entries
1081            */
1082            public java.util.List<AnnouncementsEntry> findAll(int start, int end,
1083                    com.liferay.portal.kernel.util.OrderByComparator<AnnouncementsEntry> orderByComparator);
1084    
1085            /**
1086            * Removes all the announcements entries from the database.
1087            */
1088            public void removeAll();
1089    
1090            /**
1091            * Returns the number of announcements entries.
1092            *
1093            * @return the number of announcements entries
1094            */
1095            public int countAll();
1096    }