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