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.TrashVersion;
022    
023    /**
024     * The persistence interface for the trash version 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.TrashVersionPersistenceImpl
032     * @see TrashVersionUtil
033     * @generated
034     */
035    @ProviderType
036    public interface TrashVersionPersistence extends BasePersistence<TrashVersion> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link TrashVersionUtil} to access the trash version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the trash versions where entryId = &#63;.
045            *
046            * @param entryId the entry ID
047            * @return the matching trash versions
048            */
049            public java.util.List<TrashVersion> findByEntryId(long entryId);
050    
051            /**
052            * Returns a range of all the trash versions where entryId = &#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 TrashVersionModelImpl}. 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 entryId the entry ID
059            * @param start the lower bound of the range of trash versions
060            * @param end the upper bound of the range of trash versions (not inclusive)
061            * @return the range of matching trash versions
062            */
063            public java.util.List<TrashVersion> findByEntryId(long entryId, int start,
064                    int end);
065    
066            /**
067            * Returns an ordered range of all the trash versions where entryId = &#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 TrashVersionModelImpl}. 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 entryId the entry ID
074            * @param start the lower bound of the range of trash versions
075            * @param end the upper bound of the range of trash versions (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching trash versions
078            */
079            public java.util.List<TrashVersion> findByEntryId(long entryId, int start,
080                    int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
082    
083            /**
084            * Returns an ordered range of all the trash versions where entryId = &#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 TrashVersionModelImpl}. 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 entryId the entry ID
091            * @param start the lower bound of the range of trash versions
092            * @param end the upper bound of the range of trash versions (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 versions
096            */
097            public java.util.List<TrashVersion> findByEntryId(long entryId, int start,
098                    int end,
099                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator,
100                    boolean retrieveFromCache);
101    
102            /**
103            * Returns the first trash version in the ordered set where entryId = &#63;.
104            *
105            * @param entryId the entry ID
106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
107            * @return the first matching trash version
108            * @throws NoSuchVersionException if a matching trash version could not be found
109            */
110            public TrashVersion findByEntryId_First(long entryId,
111                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator)
112                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
113    
114            /**
115            * Returns the first trash version in the ordered set where entryId = &#63;.
116            *
117            * @param entryId the entry ID
118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
119            * @return the first matching trash version, or <code>null</code> if a matching trash version could not be found
120            */
121            public TrashVersion fetchByEntryId_First(long entryId,
122                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
123    
124            /**
125            * Returns the last trash version in the ordered set where entryId = &#63;.
126            *
127            * @param entryId the entry ID
128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
129            * @return the last matching trash version
130            * @throws NoSuchVersionException if a matching trash version could not be found
131            */
132            public TrashVersion findByEntryId_Last(long entryId,
133                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator)
134                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
135    
136            /**
137            * Returns the last trash version in the ordered set where entryId = &#63;.
138            *
139            * @param entryId the entry ID
140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
141            * @return the last matching trash version, or <code>null</code> if a matching trash version could not be found
142            */
143            public TrashVersion fetchByEntryId_Last(long entryId,
144                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
145    
146            /**
147            * Returns the trash versions before and after the current trash version in the ordered set where entryId = &#63;.
148            *
149            * @param versionId the primary key of the current trash version
150            * @param entryId the entry ID
151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
152            * @return the previous, current, and next trash version
153            * @throws NoSuchVersionException if a trash version with the primary key could not be found
154            */
155            public TrashVersion[] findByEntryId_PrevAndNext(long versionId,
156                    long entryId,
157                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator)
158                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
159    
160            /**
161            * Removes all the trash versions where entryId = &#63; from the database.
162            *
163            * @param entryId the entry ID
164            */
165            public void removeByEntryId(long entryId);
166    
167            /**
168            * Returns the number of trash versions where entryId = &#63;.
169            *
170            * @param entryId the entry ID
171            * @return the number of matching trash versions
172            */
173            public int countByEntryId(long entryId);
174    
175            /**
176            * Returns all the trash versions where entryId = &#63; and classNameId = &#63;.
177            *
178            * @param entryId the entry ID
179            * @param classNameId the class name ID
180            * @return the matching trash versions
181            */
182            public java.util.List<TrashVersion> findByE_C(long entryId, long classNameId);
183    
184            /**
185            * Returns a range of all the trash versions where entryId = &#63; and classNameId = &#63;.
186            *
187            * <p>
188            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link TrashVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
189            * </p>
190            *
191            * @param entryId the entry ID
192            * @param classNameId the class name ID
193            * @param start the lower bound of the range of trash versions
194            * @param end the upper bound of the range of trash versions (not inclusive)
195            * @return the range of matching trash versions
196            */
197            public java.util.List<TrashVersion> findByE_C(long entryId,
198                    long classNameId, int start, int end);
199    
200            /**
201            * Returns an ordered range of all the trash versions where entryId = &#63; and classNameId = &#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 TrashVersionModelImpl}. 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 entryId the entry ID
208            * @param classNameId the class name ID
209            * @param start the lower bound of the range of trash versions
210            * @param end the upper bound of the range of trash versions (not inclusive)
211            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
212            * @return the ordered range of matching trash versions
213            */
214            public java.util.List<TrashVersion> findByE_C(long entryId,
215                    long classNameId, int start, int end,
216                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
217    
218            /**
219            * Returns an ordered range of all the trash versions where entryId = &#63; and classNameId = &#63;.
220            *
221            * <p>
222            * 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 TrashVersionModelImpl}. 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.
223            * </p>
224            *
225            * @param entryId the entry ID
226            * @param classNameId the class name ID
227            * @param start the lower bound of the range of trash versions
228            * @param end the upper bound of the range of trash versions (not inclusive)
229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
230            * @param retrieveFromCache whether to retrieve from the finder cache
231            * @return the ordered range of matching trash versions
232            */
233            public java.util.List<TrashVersion> findByE_C(long entryId,
234                    long classNameId, int start, int end,
235                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator,
236                    boolean retrieveFromCache);
237    
238            /**
239            * Returns the first trash version in the ordered set where entryId = &#63; and classNameId = &#63;.
240            *
241            * @param entryId the entry ID
242            * @param classNameId the class name ID
243            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
244            * @return the first matching trash version
245            * @throws NoSuchVersionException if a matching trash version could not be found
246            */
247            public TrashVersion findByE_C_First(long entryId, long classNameId,
248                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator)
249                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
250    
251            /**
252            * Returns the first trash version in the ordered set where entryId = &#63; and classNameId = &#63;.
253            *
254            * @param entryId the entry ID
255            * @param classNameId the class name ID
256            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
257            * @return the first matching trash version, or <code>null</code> if a matching trash version could not be found
258            */
259            public TrashVersion fetchByE_C_First(long entryId, long classNameId,
260                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
261    
262            /**
263            * Returns the last trash version in the ordered set where entryId = &#63; and classNameId = &#63;.
264            *
265            * @param entryId the entry ID
266            * @param classNameId the class name ID
267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
268            * @return the last matching trash version
269            * @throws NoSuchVersionException if a matching trash version could not be found
270            */
271            public TrashVersion findByE_C_Last(long entryId, long classNameId,
272                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator)
273                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
274    
275            /**
276            * Returns the last trash version in the ordered set where entryId = &#63; and classNameId = &#63;.
277            *
278            * @param entryId the entry ID
279            * @param classNameId the class name ID
280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
281            * @return the last matching trash version, or <code>null</code> if a matching trash version could not be found
282            */
283            public TrashVersion fetchByE_C_Last(long entryId, long classNameId,
284                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
285    
286            /**
287            * Returns the trash versions before and after the current trash version in the ordered set where entryId = &#63; and classNameId = &#63;.
288            *
289            * @param versionId the primary key of the current trash version
290            * @param entryId the entry ID
291            * @param classNameId the class name ID
292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
293            * @return the previous, current, and next trash version
294            * @throws NoSuchVersionException if a trash version with the primary key could not be found
295            */
296            public TrashVersion[] findByE_C_PrevAndNext(long versionId, long entryId,
297                    long classNameId,
298                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator)
299                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
300    
301            /**
302            * Removes all the trash versions where entryId = &#63; and classNameId = &#63; from the database.
303            *
304            * @param entryId the entry ID
305            * @param classNameId the class name ID
306            */
307            public void removeByE_C(long entryId, long classNameId);
308    
309            /**
310            * Returns the number of trash versions where entryId = &#63; and classNameId = &#63;.
311            *
312            * @param entryId the entry ID
313            * @param classNameId the class name ID
314            * @return the number of matching trash versions
315            */
316            public int countByE_C(long entryId, long classNameId);
317    
318            /**
319            * Returns the trash version where classNameId = &#63; and classPK = &#63; or throws a {@link NoSuchVersionException} if it could not be found.
320            *
321            * @param classNameId the class name ID
322            * @param classPK the class p k
323            * @return the matching trash version
324            * @throws NoSuchVersionException if a matching trash version could not be found
325            */
326            public TrashVersion findByC_C(long classNameId, long classPK)
327                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
328    
329            /**
330            * Returns the trash version where classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
331            *
332            * @param classNameId the class name ID
333            * @param classPK the class p k
334            * @return the matching trash version, or <code>null</code> if a matching trash version could not be found
335            */
336            public TrashVersion fetchByC_C(long classNameId, long classPK);
337    
338            /**
339            * Returns the trash version where classNameId = &#63; and classPK = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
340            *
341            * @param classNameId the class name ID
342            * @param classPK the class p k
343            * @param retrieveFromCache whether to retrieve from the finder cache
344            * @return the matching trash version, or <code>null</code> if a matching trash version could not be found
345            */
346            public TrashVersion fetchByC_C(long classNameId, long classPK,
347                    boolean retrieveFromCache);
348    
349            /**
350            * Removes the trash version where classNameId = &#63; and classPK = &#63; from the database.
351            *
352            * @param classNameId the class name ID
353            * @param classPK the class p k
354            * @return the trash version that was removed
355            */
356            public TrashVersion removeByC_C(long classNameId, long classPK)
357                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
358    
359            /**
360            * Returns the number of trash versions where classNameId = &#63; and classPK = &#63;.
361            *
362            * @param classNameId the class name ID
363            * @param classPK the class p k
364            * @return the number of matching trash versions
365            */
366            public int countByC_C(long classNameId, long classPK);
367    
368            /**
369            * Caches the trash version in the entity cache if it is enabled.
370            *
371            * @param trashVersion the trash version
372            */
373            public void cacheResult(TrashVersion trashVersion);
374    
375            /**
376            * Caches the trash versions in the entity cache if it is enabled.
377            *
378            * @param trashVersions the trash versions
379            */
380            public void cacheResult(java.util.List<TrashVersion> trashVersions);
381    
382            /**
383            * Creates a new trash version with the primary key. Does not add the trash version to the database.
384            *
385            * @param versionId the primary key for the new trash version
386            * @return the new trash version
387            */
388            public TrashVersion create(long versionId);
389    
390            /**
391            * Removes the trash version with the primary key from the database. Also notifies the appropriate model listeners.
392            *
393            * @param versionId the primary key of the trash version
394            * @return the trash version that was removed
395            * @throws NoSuchVersionException if a trash version with the primary key could not be found
396            */
397            public TrashVersion remove(long versionId)
398                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
399    
400            public TrashVersion updateImpl(TrashVersion trashVersion);
401    
402            /**
403            * Returns the trash version with the primary key or throws a {@link NoSuchVersionException} if it could not be found.
404            *
405            * @param versionId the primary key of the trash version
406            * @return the trash version
407            * @throws NoSuchVersionException if a trash version with the primary key could not be found
408            */
409            public TrashVersion findByPrimaryKey(long versionId)
410                    throws com.liferay.portlet.trash.exception.NoSuchVersionException;
411    
412            /**
413            * Returns the trash version with the primary key or returns <code>null</code> if it could not be found.
414            *
415            * @param versionId the primary key of the trash version
416            * @return the trash version, or <code>null</code> if a trash version with the primary key could not be found
417            */
418            public TrashVersion fetchByPrimaryKey(long versionId);
419    
420            @Override
421            public java.util.Map<java.io.Serializable, TrashVersion> fetchByPrimaryKeys(
422                    java.util.Set<java.io.Serializable> primaryKeys);
423    
424            /**
425            * Returns all the trash versions.
426            *
427            * @return the trash versions
428            */
429            public java.util.List<TrashVersion> findAll();
430    
431            /**
432            * Returns a range of all the trash versions.
433            *
434            * <p>
435            * 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 TrashVersionModelImpl}. 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.
436            * </p>
437            *
438            * @param start the lower bound of the range of trash versions
439            * @param end the upper bound of the range of trash versions (not inclusive)
440            * @return the range of trash versions
441            */
442            public java.util.List<TrashVersion> findAll(int start, int end);
443    
444            /**
445            * Returns an ordered range of all the trash versions.
446            *
447            * <p>
448            * 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 TrashVersionModelImpl}. 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.
449            * </p>
450            *
451            * @param start the lower bound of the range of trash versions
452            * @param end the upper bound of the range of trash versions (not inclusive)
453            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
454            * @return the ordered range of trash versions
455            */
456            public java.util.List<TrashVersion> findAll(int start, int end,
457                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator);
458    
459            /**
460            * Returns an ordered range of all the trash versions.
461            *
462            * <p>
463            * 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 TrashVersionModelImpl}. 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.
464            * </p>
465            *
466            * @param start the lower bound of the range of trash versions
467            * @param end the upper bound of the range of trash versions (not inclusive)
468            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
469            * @param retrieveFromCache whether to retrieve from the finder cache
470            * @return the ordered range of trash versions
471            */
472            public java.util.List<TrashVersion> findAll(int start, int end,
473                    com.liferay.portal.kernel.util.OrderByComparator<TrashVersion> orderByComparator,
474                    boolean retrieveFromCache);
475    
476            /**
477            * Removes all the trash versions from the database.
478            */
479            public void removeAll();
480    
481            /**
482            * Returns the number of trash versions.
483            *
484            * @return the number of trash versions
485            */
486            public int countAll();
487    }