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