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