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.trash.kernel.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.service.persistence.BasePersistence;
020    
021    import com.liferay.trash.kernel.exception.NoSuchEntryException;
022    import com.liferay.trash.kernel.model.TrashEntry;
023    
024    import java.util.Date;
025    
026    /**
027     * The persistence interface for the trash entry service.
028     *
029     * <p>
030     * Caching information and settings can be found in <code>portal.properties</code>
031     * </p>
032     *
033     * @author Brian Wing Shun Chan
034     * @see com.liferay.portlet.trash.service.persistence.impl.TrashEntryPersistenceImpl
035     * @see TrashEntryUtil
036     * @generated
037     */
038    @ProviderType
039    public interface TrashEntryPersistence extends BasePersistence<TrashEntry> {
040            /*
041             * NOTE FOR DEVELOPERS:
042             *
043             * Never modify or reference this interface directly. Always use {@link TrashEntryUtil} to access the trash entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
044             */
045    
046            /**
047            * Returns all the trash entries where groupId = &#63;.
048            *
049            * @param groupId the group ID
050            * @return the matching trash entries
051            */
052            public java.util.List<TrashEntry> findByGroupId(long groupId);
053    
054            /**
055            * Returns a range of all the trash entries where groupId = &#63;.
056            *
057            * <p>
058            * 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 TrashEntryModelImpl}. 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.
059            * </p>
060            *
061            * @param groupId the group ID
062            * @param start the lower bound of the range of trash entries
063            * @param end the upper bound of the range of trash entries (not inclusive)
064            * @return the range of matching trash entries
065            */
066            public java.util.List<TrashEntry> findByGroupId(long groupId, int start,
067                    int end);
068    
069            /**
070            * Returns an ordered range of all the trash entries where groupId = &#63;.
071            *
072            * <p>
073            * 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 TrashEntryModelImpl}. 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.
074            * </p>
075            *
076            * @param groupId the group ID
077            * @param start the lower bound of the range of trash entries
078            * @param end the upper bound of the range of trash entries (not inclusive)
079            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
080            * @return the ordered range of matching trash entries
081            */
082            public java.util.List<TrashEntry> findByGroupId(long groupId, int start,
083                    int end,
084                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
085    
086            /**
087            * Returns an ordered range of all the trash entries where groupId = &#63;.
088            *
089            * <p>
090            * 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 TrashEntryModelImpl}. 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.
091            * </p>
092            *
093            * @param groupId the group ID
094            * @param start the lower bound of the range of trash entries
095            * @param end the upper bound of the range of trash entries (not inclusive)
096            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
097            * @param retrieveFromCache whether to retrieve from the finder cache
098            * @return the ordered range of matching trash entries
099            */
100            public java.util.List<TrashEntry> findByGroupId(long groupId, int start,
101                    int end,
102                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator,
103                    boolean retrieveFromCache);
104    
105            /**
106            * Returns the first trash entry in the ordered set where groupId = &#63;.
107            *
108            * @param groupId the group ID
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the first matching trash entry
111            * @throws NoSuchEntryException if a matching trash entry could not be found
112            */
113            public TrashEntry findByGroupId_First(long groupId,
114                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
115                    throws NoSuchEntryException;
116    
117            /**
118            * Returns the first trash entry in the ordered set where groupId = &#63;.
119            *
120            * @param groupId the group ID
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found
123            */
124            public TrashEntry fetchByGroupId_First(long groupId,
125                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
126    
127            /**
128            * Returns the last trash entry in the ordered set where groupId = &#63;.
129            *
130            * @param groupId the group ID
131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
132            * @return the last matching trash entry
133            * @throws NoSuchEntryException if a matching trash entry could not be found
134            */
135            public TrashEntry findByGroupId_Last(long groupId,
136                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
137                    throws NoSuchEntryException;
138    
139            /**
140            * Returns the last trash entry in the ordered set where groupId = &#63;.
141            *
142            * @param groupId the group ID
143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
144            * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found
145            */
146            public TrashEntry fetchByGroupId_Last(long groupId,
147                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
148    
149            /**
150            * Returns the trash entries before and after the current trash entry in the ordered set where groupId = &#63;.
151            *
152            * @param entryId the primary key of the current trash entry
153            * @param groupId the group ID
154            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
155            * @return the previous, current, and next trash entry
156            * @throws NoSuchEntryException if a trash entry with the primary key could not be found
157            */
158            public TrashEntry[] findByGroupId_PrevAndNext(long entryId, long groupId,
159                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
160                    throws NoSuchEntryException;
161    
162            /**
163            * Removes all the trash entries where groupId = &#63; from the database.
164            *
165            * @param groupId the group ID
166            */
167            public void removeByGroupId(long groupId);
168    
169            /**
170            * Returns the number of trash entries where groupId = &#63;.
171            *
172            * @param groupId the group ID
173            * @return the number of matching trash entries
174            */
175            public int countByGroupId(long groupId);
176    
177            /**
178            * Returns all the trash entries where companyId = &#63;.
179            *
180            * @param companyId the company ID
181            * @return the matching trash entries
182            */
183            public java.util.List<TrashEntry> findByCompanyId(long companyId);
184    
185            /**
186            * Returns a range of all the trash entries where companyId = &#63;.
187            *
188            * <p>
189            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TrashEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
190            * </p>
191            *
192            * @param companyId the company ID
193            * @param start the lower bound of the range of trash entries
194            * @param end the upper bound of the range of trash entries (not inclusive)
195            * @return the range of matching trash entries
196            */
197            public java.util.List<TrashEntry> findByCompanyId(long companyId,
198                    int start, int end);
199    
200            /**
201            * Returns an ordered range of all the trash entries where companyId = &#63;.
202            *
203            * <p>
204            * 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 TrashEntryModelImpl}. 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.
205            * </p>
206            *
207            * @param companyId the company ID
208            * @param start the lower bound of the range of trash entries
209            * @param end the upper bound of the range of trash entries (not inclusive)
210            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
211            * @return the ordered range of matching trash entries
212            */
213            public java.util.List<TrashEntry> findByCompanyId(long companyId,
214                    int start, int end,
215                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
216    
217            /**
218            * Returns an ordered range of all the trash entries where companyId = &#63;.
219            *
220            * <p>
221            * 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 TrashEntryModelImpl}. 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.
222            * </p>
223            *
224            * @param companyId the company ID
225            * @param start the lower bound of the range of trash entries
226            * @param end the upper bound of the range of trash entries (not inclusive)
227            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
228            * @param retrieveFromCache whether to retrieve from the finder cache
229            * @return the ordered range of matching trash entries
230            */
231            public java.util.List<TrashEntry> findByCompanyId(long companyId,
232                    int start, int end,
233                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator,
234                    boolean retrieveFromCache);
235    
236            /**
237            * Returns the first trash entry in the ordered set where companyId = &#63;.
238            *
239            * @param companyId the company ID
240            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
241            * @return the first matching trash entry
242            * @throws NoSuchEntryException if a matching trash entry could not be found
243            */
244            public TrashEntry findByCompanyId_First(long companyId,
245                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
246                    throws NoSuchEntryException;
247    
248            /**
249            * Returns the first trash entry in the ordered set where companyId = &#63;.
250            *
251            * @param companyId the company ID
252            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
253            * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found
254            */
255            public TrashEntry fetchByCompanyId_First(long companyId,
256                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
257    
258            /**
259            * Returns the last trash entry in the ordered set where companyId = &#63;.
260            *
261            * @param companyId the company ID
262            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
263            * @return the last matching trash entry
264            * @throws NoSuchEntryException if a matching trash entry could not be found
265            */
266            public TrashEntry findByCompanyId_Last(long companyId,
267                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
268                    throws NoSuchEntryException;
269    
270            /**
271            * Returns the last trash entry in the ordered set where companyId = &#63;.
272            *
273            * @param companyId the company ID
274            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
275            * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found
276            */
277            public TrashEntry fetchByCompanyId_Last(long companyId,
278                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
279    
280            /**
281            * Returns the trash entries before and after the current trash entry in the ordered set where companyId = &#63;.
282            *
283            * @param entryId the primary key of the current trash entry
284            * @param companyId the company ID
285            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
286            * @return the previous, current, and next trash entry
287            * @throws NoSuchEntryException if a trash entry with the primary key could not be found
288            */
289            public TrashEntry[] findByCompanyId_PrevAndNext(long entryId,
290                    long companyId,
291                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
292                    throws NoSuchEntryException;
293    
294            /**
295            * Removes all the trash entries where companyId = &#63; from the database.
296            *
297            * @param companyId the company ID
298            */
299            public void removeByCompanyId(long companyId);
300    
301            /**
302            * Returns the number of trash entries where companyId = &#63;.
303            *
304            * @param companyId the company ID
305            * @return the number of matching trash entries
306            */
307            public int countByCompanyId(long companyId);
308    
309            /**
310            * Returns all the trash entries where groupId = &#63; and createDate &lt; &#63;.
311            *
312            * @param groupId the group ID
313            * @param createDate the create date
314            * @return the matching trash entries
315            */
316            public java.util.List<TrashEntry> findByG_LtCD(long groupId, Date createDate);
317    
318            /**
319            * Returns a range of all the trash entries where groupId = &#63; and createDate &lt; &#63;.
320            *
321            * <p>
322            * 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 TrashEntryModelImpl}. 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.
323            * </p>
324            *
325            * @param groupId the group ID
326            * @param createDate the create date
327            * @param start the lower bound of the range of trash entries
328            * @param end the upper bound of the range of trash entries (not inclusive)
329            * @return the range of matching trash entries
330            */
331            public java.util.List<TrashEntry> findByG_LtCD(long groupId,
332                    Date createDate, int start, int end);
333    
334            /**
335            * Returns an ordered range of all the trash entries where groupId = &#63; and createDate &lt; &#63;.
336            *
337            * <p>
338            * 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 TrashEntryModelImpl}. 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.
339            * </p>
340            *
341            * @param groupId the group ID
342            * @param createDate the create date
343            * @param start the lower bound of the range of trash entries
344            * @param end the upper bound of the range of trash entries (not inclusive)
345            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
346            * @return the ordered range of matching trash entries
347            */
348            public java.util.List<TrashEntry> findByG_LtCD(long groupId,
349                    Date createDate, int start, int end,
350                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
351    
352            /**
353            * Returns an ordered range of all the trash entries where groupId = &#63; and createDate &lt; &#63;.
354            *
355            * <p>
356            * 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 TrashEntryModelImpl}. 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.
357            * </p>
358            *
359            * @param groupId the group ID
360            * @param createDate the create date
361            * @param start the lower bound of the range of trash entries
362            * @param end the upper bound of the range of trash entries (not inclusive)
363            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
364            * @param retrieveFromCache whether to retrieve from the finder cache
365            * @return the ordered range of matching trash entries
366            */
367            public java.util.List<TrashEntry> findByG_LtCD(long groupId,
368                    Date createDate, int start, int end,
369                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator,
370                    boolean retrieveFromCache);
371    
372            /**
373            * Returns the first trash entry in the ordered set where groupId = &#63; and createDate &lt; &#63;.
374            *
375            * @param groupId the group ID
376            * @param createDate the create date
377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
378            * @return the first matching trash entry
379            * @throws NoSuchEntryException if a matching trash entry could not be found
380            */
381            public TrashEntry findByG_LtCD_First(long groupId, Date createDate,
382                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
383                    throws NoSuchEntryException;
384    
385            /**
386            * Returns the first trash entry in the ordered set where groupId = &#63; and createDate &lt; &#63;.
387            *
388            * @param groupId the group ID
389            * @param createDate the create date
390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
391            * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found
392            */
393            public TrashEntry fetchByG_LtCD_First(long groupId, Date createDate,
394                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
395    
396            /**
397            * Returns the last trash entry in the ordered set where groupId = &#63; and createDate &lt; &#63;.
398            *
399            * @param groupId the group ID
400            * @param createDate the create date
401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
402            * @return the last matching trash entry
403            * @throws NoSuchEntryException if a matching trash entry could not be found
404            */
405            public TrashEntry findByG_LtCD_Last(long groupId, Date createDate,
406                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
407                    throws NoSuchEntryException;
408    
409            /**
410            * Returns the last trash entry in the ordered set where groupId = &#63; and createDate &lt; &#63;.
411            *
412            * @param groupId the group ID
413            * @param createDate the create date
414            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
415            * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found
416            */
417            public TrashEntry fetchByG_LtCD_Last(long groupId, Date createDate,
418                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
419    
420            /**
421            * Returns the trash entries before and after the current trash entry in the ordered set where groupId = &#63; and createDate &lt; &#63;.
422            *
423            * @param entryId the primary key of the current trash entry
424            * @param groupId the group ID
425            * @param createDate the create date
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the previous, current, and next trash entry
428            * @throws NoSuchEntryException if a trash entry with the primary key could not be found
429            */
430            public TrashEntry[] findByG_LtCD_PrevAndNext(long entryId, long groupId,
431                    Date createDate,
432                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
433                    throws NoSuchEntryException;
434    
435            /**
436            * Removes all the trash entries where groupId = &#63; and createDate &lt; &#63; from the database.
437            *
438            * @param groupId the group ID
439            * @param createDate the create date
440            */
441            public void removeByG_LtCD(long groupId, Date createDate);
442    
443            /**
444            * Returns the number of trash entries where groupId = &#63; and createDate &lt; &#63;.
445            *
446            * @param groupId the group ID
447            * @param createDate the create date
448            * @return the number of matching trash entries
449            */
450            public int countByG_LtCD(long groupId, Date createDate);
451    
452            /**
453            * Returns all the trash entries where groupId = &#63; and classNameId = &#63;.
454            *
455            * @param groupId the group ID
456            * @param classNameId the class name ID
457            * @return the matching trash entries
458            */
459            public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId);
460    
461            /**
462            * Returns a range of all the trash entries where groupId = &#63; and classNameId = &#63;.
463            *
464            * <p>
465            * 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 TrashEntryModelImpl}. 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.
466            * </p>
467            *
468            * @param groupId the group ID
469            * @param classNameId the class name ID
470            * @param start the lower bound of the range of trash entries
471            * @param end the upper bound of the range of trash entries (not inclusive)
472            * @return the range of matching trash entries
473            */
474            public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId,
475                    int start, int end);
476    
477            /**
478            * Returns an ordered range of all the trash entries where groupId = &#63; and classNameId = &#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 TrashEntryModelImpl}. 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 groupId the group ID
485            * @param classNameId the class name ID
486            * @param start the lower bound of the range of trash entries
487            * @param end the upper bound of the range of trash entries (not inclusive)
488            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
489            * @return the ordered range of matching trash entries
490            */
491            public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId,
492                    int start, int end,
493                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
494    
495            /**
496            * Returns an ordered range of all the trash entries where groupId = &#63; and classNameId = &#63;.
497            *
498            * <p>
499            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TrashEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
500            * </p>
501            *
502            * @param groupId the group ID
503            * @param classNameId the class name ID
504            * @param start the lower bound of the range of trash entries
505            * @param end the upper bound of the range of trash entries (not inclusive)
506            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
507            * @param retrieveFromCache whether to retrieve from the finder cache
508            * @return the ordered range of matching trash entries
509            */
510            public java.util.List<TrashEntry> findByG_C(long groupId, long classNameId,
511                    int start, int end,
512                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator,
513                    boolean retrieveFromCache);
514    
515            /**
516            * Returns the first trash entry in the ordered set where groupId = &#63; and classNameId = &#63;.
517            *
518            * @param groupId the group ID
519            * @param classNameId the class name ID
520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
521            * @return the first matching trash entry
522            * @throws NoSuchEntryException if a matching trash entry could not be found
523            */
524            public TrashEntry findByG_C_First(long groupId, long classNameId,
525                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
526                    throws NoSuchEntryException;
527    
528            /**
529            * Returns the first trash entry in the ordered set where groupId = &#63; and classNameId = &#63;.
530            *
531            * @param groupId the group ID
532            * @param classNameId the class name ID
533            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
534            * @return the first matching trash entry, or <code>null</code> if a matching trash entry could not be found
535            */
536            public TrashEntry fetchByG_C_First(long groupId, long classNameId,
537                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
538    
539            /**
540            * Returns the last trash entry in the ordered set where groupId = &#63; and classNameId = &#63;.
541            *
542            * @param groupId the group ID
543            * @param classNameId the class name ID
544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
545            * @return the last matching trash entry
546            * @throws NoSuchEntryException if a matching trash entry could not be found
547            */
548            public TrashEntry findByG_C_Last(long groupId, long classNameId,
549                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
550                    throws NoSuchEntryException;
551    
552            /**
553            * Returns the last trash entry in the ordered set where groupId = &#63; and classNameId = &#63;.
554            *
555            * @param groupId the group ID
556            * @param classNameId the class name ID
557            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
558            * @return the last matching trash entry, or <code>null</code> if a matching trash entry could not be found
559            */
560            public TrashEntry fetchByG_C_Last(long groupId, long classNameId,
561                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
562    
563            /**
564            * Returns the trash entries before and after the current trash entry in the ordered set where groupId = &#63; and classNameId = &#63;.
565            *
566            * @param entryId the primary key of the current trash entry
567            * @param groupId the group ID
568            * @param classNameId the class name ID
569            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
570            * @return the previous, current, and next trash entry
571            * @throws NoSuchEntryException if a trash entry with the primary key could not be found
572            */
573            public TrashEntry[] findByG_C_PrevAndNext(long entryId, long groupId,
574                    long classNameId,
575                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator)
576                    throws NoSuchEntryException;
577    
578            /**
579            * Removes all the trash entries where groupId = &#63; and classNameId = &#63; from the database.
580            *
581            * @param groupId the group ID
582            * @param classNameId the class name ID
583            */
584            public void removeByG_C(long groupId, long classNameId);
585    
586            /**
587            * Returns the number of trash entries where groupId = &#63; and classNameId = &#63;.
588            *
589            * @param groupId the group ID
590            * @param classNameId the class name ID
591            * @return the number of matching trash entries
592            */
593            public int countByG_C(long groupId, long classNameId);
594    
595            /**
596            * Returns the trash entry where classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchEntryException} if it could not be found.
597            *
598            * @param classNameId the class name ID
599            * @param classPK the class p k
600            * @return the matching trash entry
601            * @throws NoSuchEntryException if a matching trash entry could not be found
602            */
603            public TrashEntry findByC_C(long classNameId, long classPK)
604                    throws NoSuchEntryException;
605    
606            /**
607            * Returns the trash entry where classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
608            *
609            * @param classNameId the class name ID
610            * @param classPK the class p k
611            * @return the matching trash entry, or <code>null</code> if a matching trash entry could not be found
612            */
613            public TrashEntry fetchByC_C(long classNameId, long classPK);
614    
615            /**
616            * Returns the trash entry where classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
617            *
618            * @param classNameId the class name ID
619            * @param classPK the class p k
620            * @param retrieveFromCache whether to retrieve from the finder cache
621            * @return the matching trash entry, or <code>null</code> if a matching trash entry could not be found
622            */
623            public TrashEntry fetchByC_C(long classNameId, long classPK,
624                    boolean retrieveFromCache);
625    
626            /**
627            * Removes the trash entry where classNameId = &#63; and classPK = &#63; from the database.
628            *
629            * @param classNameId the class name ID
630            * @param classPK the class p k
631            * @return the trash entry that was removed
632            */
633            public TrashEntry removeByC_C(long classNameId, long classPK)
634                    throws NoSuchEntryException;
635    
636            /**
637            * Returns the number of trash entries where classNameId = &#63; and classPK = &#63;.
638            *
639            * @param classNameId the class name ID
640            * @param classPK the class p k
641            * @return the number of matching trash entries
642            */
643            public int countByC_C(long classNameId, long classPK);
644    
645            /**
646            * Caches the trash entry in the entity cache if it is enabled.
647            *
648            * @param trashEntry the trash entry
649            */
650            public void cacheResult(TrashEntry trashEntry);
651    
652            /**
653            * Caches the trash entries in the entity cache if it is enabled.
654            *
655            * @param trashEntries the trash entries
656            */
657            public void cacheResult(java.util.List<TrashEntry> trashEntries);
658    
659            /**
660            * Creates a new trash entry with the primary key. Does not add the trash entry to the database.
661            *
662            * @param entryId the primary key for the new trash entry
663            * @return the new trash entry
664            */
665            public TrashEntry create(long entryId);
666    
667            /**
668            * Removes the trash entry with the primary key from the database. Also notifies the appropriate model listeners.
669            *
670            * @param entryId the primary key of the trash entry
671            * @return the trash entry that was removed
672            * @throws NoSuchEntryException if a trash entry with the primary key could not be found
673            */
674            public TrashEntry remove(long entryId) throws NoSuchEntryException;
675    
676            public TrashEntry updateImpl(TrashEntry trashEntry);
677    
678            /**
679            * Returns the trash entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found.
680            *
681            * @param entryId the primary key of the trash entry
682            * @return the trash entry
683            * @throws NoSuchEntryException if a trash entry with the primary key could not be found
684            */
685            public TrashEntry findByPrimaryKey(long entryId)
686                    throws NoSuchEntryException;
687    
688            /**
689            * Returns the trash entry with the primary key or returns <code>null</code> if it could not be found.
690            *
691            * @param entryId the primary key of the trash entry
692            * @return the trash entry, or <code>null</code> if a trash entry with the primary key could not be found
693            */
694            public TrashEntry fetchByPrimaryKey(long entryId);
695    
696            @Override
697            public java.util.Map<java.io.Serializable, TrashEntry> fetchByPrimaryKeys(
698                    java.util.Set<java.io.Serializable> primaryKeys);
699    
700            /**
701            * Returns all the trash entries.
702            *
703            * @return the trash entries
704            */
705            public java.util.List<TrashEntry> findAll();
706    
707            /**
708            * Returns a range of all the trash entries.
709            *
710            * <p>
711            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TrashEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
712            * </p>
713            *
714            * @param start the lower bound of the range of trash entries
715            * @param end the upper bound of the range of trash entries (not inclusive)
716            * @return the range of trash entries
717            */
718            public java.util.List<TrashEntry> findAll(int start, int end);
719    
720            /**
721            * Returns an ordered range of all the trash entries.
722            *
723            * <p>
724            * 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 TrashEntryModelImpl}. 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.
725            * </p>
726            *
727            * @param start the lower bound of the range of trash entries
728            * @param end the upper bound of the range of trash entries (not inclusive)
729            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
730            * @return the ordered range of trash entries
731            */
732            public java.util.List<TrashEntry> findAll(int start, int end,
733                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator);
734    
735            /**
736            * Returns an ordered range of all the trash entries.
737            *
738            * <p>
739            * 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 TrashEntryModelImpl}. 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.
740            * </p>
741            *
742            * @param start the lower bound of the range of trash entries
743            * @param end the upper bound of the range of trash entries (not inclusive)
744            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
745            * @param retrieveFromCache whether to retrieve from the finder cache
746            * @return the ordered range of trash entries
747            */
748            public java.util.List<TrashEntry> findAll(int start, int end,
749                    com.liferay.portal.kernel.util.OrderByComparator<TrashEntry> orderByComparator,
750                    boolean retrieveFromCache);
751    
752            /**
753            * Removes all the trash entries from the database.
754            */
755            public void removeAll();
756    
757            /**
758            * Returns the number of trash entries.
759            *
760            * @return the number of trash entries
761            */
762            public int countAll();
763    }