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.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.model.LayoutRevision;
020    
021    /**
022     * The persistence interface for the layout revision service.
023     *
024     * <p>
025     * Caching information and settings can be found in <code>portal.properties</code>
026     * </p>
027     *
028     * @author Brian Wing Shun Chan
029     * @see com.liferay.portal.service.persistence.impl.LayoutRevisionPersistenceImpl
030     * @see LayoutRevisionUtil
031     * @generated
032     */
033    @ProviderType
034    public interface LayoutRevisionPersistence extends BasePersistence<LayoutRevision> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link LayoutRevisionUtil} to access the layout revision persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the layout revisions where layoutSetBranchId = &#63;.
043            *
044            * @param layoutSetBranchId the layout set branch ID
045            * @return the matching layout revisions
046            */
047            public java.util.List<LayoutRevision> findByLayoutSetBranchId(
048                    long layoutSetBranchId);
049    
050            /**
051            * Returns a range of all the layout revisions where layoutSetBranchId = &#63;.
052            *
053            * <p>
054            * 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 LayoutRevisionModelImpl}. 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.
055            * </p>
056            *
057            * @param layoutSetBranchId the layout set branch ID
058            * @param start the lower bound of the range of layout revisions
059            * @param end the upper bound of the range of layout revisions (not inclusive)
060            * @return the range of matching layout revisions
061            */
062            public java.util.List<LayoutRevision> findByLayoutSetBranchId(
063                    long layoutSetBranchId, int start, int end);
064    
065            /**
066            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63;.
067            *
068            * <p>
069            * 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 LayoutRevisionModelImpl}. 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.
070            * </p>
071            *
072            * @param layoutSetBranchId the layout set branch ID
073            * @param start the lower bound of the range of layout revisions
074            * @param end the upper bound of the range of layout revisions (not inclusive)
075            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
076            * @return the ordered range of matching layout revisions
077            */
078            public java.util.List<LayoutRevision> findByLayoutSetBranchId(
079                    long layoutSetBranchId, int start, int end,
080                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
081    
082            /**
083            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63;.
084            *
085            * <p>
086            * 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 LayoutRevisionModelImpl}. 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.
087            * </p>
088            *
089            * @param layoutSetBranchId the layout set branch ID
090            * @param start the lower bound of the range of layout revisions
091            * @param end the upper bound of the range of layout revisions (not inclusive)
092            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
093            * @param retrieveFromCache whether to retrieve from the finder cache
094            * @return the ordered range of matching layout revisions
095            */
096            public java.util.List<LayoutRevision> findByLayoutSetBranchId(
097                    long layoutSetBranchId, int start, int end,
098                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
099                    boolean retrieveFromCache);
100    
101            /**
102            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63;.
103            *
104            * @param layoutSetBranchId the layout set branch ID
105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
106            * @return the first matching layout revision
107            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
108            */
109            public LayoutRevision findByLayoutSetBranchId_First(
110                    long layoutSetBranchId,
111                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
112                    throws com.liferay.portal.NoSuchLayoutRevisionException;
113    
114            /**
115            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63;.
116            *
117            * @param layoutSetBranchId the layout set branch ID
118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
119            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
120            */
121            public LayoutRevision fetchByLayoutSetBranchId_First(
122                    long layoutSetBranchId,
123                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
124    
125            /**
126            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63;.
127            *
128            * @param layoutSetBranchId the layout set branch ID
129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
130            * @return the last matching layout revision
131            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
132            */
133            public LayoutRevision findByLayoutSetBranchId_Last(long layoutSetBranchId,
134                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
135                    throws com.liferay.portal.NoSuchLayoutRevisionException;
136    
137            /**
138            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63;.
139            *
140            * @param layoutSetBranchId the layout set branch ID
141            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
142            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
143            */
144            public LayoutRevision fetchByLayoutSetBranchId_Last(
145                    long layoutSetBranchId,
146                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
147    
148            /**
149            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63;.
150            *
151            * @param layoutRevisionId the primary key of the current layout revision
152            * @param layoutSetBranchId the layout set branch ID
153            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
154            * @return the previous, current, and next layout revision
155            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
156            */
157            public LayoutRevision[] findByLayoutSetBranchId_PrevAndNext(
158                    long layoutRevisionId, long layoutSetBranchId,
159                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
160                    throws com.liferay.portal.NoSuchLayoutRevisionException;
161    
162            /**
163            * Removes all the layout revisions where layoutSetBranchId = &#63; from the database.
164            *
165            * @param layoutSetBranchId the layout set branch ID
166            */
167            public void removeByLayoutSetBranchId(long layoutSetBranchId);
168    
169            /**
170            * Returns the number of layout revisions where layoutSetBranchId = &#63;.
171            *
172            * @param layoutSetBranchId the layout set branch ID
173            * @return the number of matching layout revisions
174            */
175            public int countByLayoutSetBranchId(long layoutSetBranchId);
176    
177            /**
178            * Returns all the layout revisions where plid = &#63;.
179            *
180            * @param plid the plid
181            * @return the matching layout revisions
182            */
183            public java.util.List<LayoutRevision> findByPlid(long plid);
184    
185            /**
186            * Returns a range of all the layout revisions where plid = &#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 LayoutRevisionModelImpl}. 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 plid the plid
193            * @param start the lower bound of the range of layout revisions
194            * @param end the upper bound of the range of layout revisions (not inclusive)
195            * @return the range of matching layout revisions
196            */
197            public java.util.List<LayoutRevision> findByPlid(long plid, int start,
198                    int end);
199    
200            /**
201            * Returns an ordered range of all the layout revisions where plid = &#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 LayoutRevisionModelImpl}. 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 plid the plid
208            * @param start the lower bound of the range of layout revisions
209            * @param end the upper bound of the range of layout revisions (not inclusive)
210            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
211            * @return the ordered range of matching layout revisions
212            */
213            public java.util.List<LayoutRevision> findByPlid(long plid, int start,
214                    int end,
215                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
216    
217            /**
218            * Returns an ordered range of all the layout revisions where plid = &#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 LayoutRevisionModelImpl}. 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 plid the plid
225            * @param start the lower bound of the range of layout revisions
226            * @param end the upper bound of the range of layout revisions (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 layout revisions
230            */
231            public java.util.List<LayoutRevision> findByPlid(long plid, int start,
232                    int end,
233                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
234                    boolean retrieveFromCache);
235    
236            /**
237            * Returns the first layout revision in the ordered set where plid = &#63;.
238            *
239            * @param plid the plid
240            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
241            * @return the first matching layout revision
242            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
243            */
244            public LayoutRevision findByPlid_First(long plid,
245                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
246                    throws com.liferay.portal.NoSuchLayoutRevisionException;
247    
248            /**
249            * Returns the first layout revision in the ordered set where plid = &#63;.
250            *
251            * @param plid the plid
252            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
253            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
254            */
255            public LayoutRevision fetchByPlid_First(long plid,
256                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
257    
258            /**
259            * Returns the last layout revision in the ordered set where plid = &#63;.
260            *
261            * @param plid the plid
262            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
263            * @return the last matching layout revision
264            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
265            */
266            public LayoutRevision findByPlid_Last(long plid,
267                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
268                    throws com.liferay.portal.NoSuchLayoutRevisionException;
269    
270            /**
271            * Returns the last layout revision in the ordered set where plid = &#63;.
272            *
273            * @param plid the plid
274            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
275            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
276            */
277            public LayoutRevision fetchByPlid_Last(long plid,
278                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
279    
280            /**
281            * Returns the layout revisions before and after the current layout revision in the ordered set where plid = &#63;.
282            *
283            * @param layoutRevisionId the primary key of the current layout revision
284            * @param plid the plid
285            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
286            * @return the previous, current, and next layout revision
287            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
288            */
289            public LayoutRevision[] findByPlid_PrevAndNext(long layoutRevisionId,
290                    long plid,
291                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
292                    throws com.liferay.portal.NoSuchLayoutRevisionException;
293    
294            /**
295            * Removes all the layout revisions where plid = &#63; from the database.
296            *
297            * @param plid the plid
298            */
299            public void removeByPlid(long plid);
300    
301            /**
302            * Returns the number of layout revisions where plid = &#63;.
303            *
304            * @param plid the plid
305            * @return the number of matching layout revisions
306            */
307            public int countByPlid(long plid);
308    
309            /**
310            * Returns all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
311            *
312            * @param layoutSetBranchId the layout set branch ID
313            * @param head the head
314            * @return the matching layout revisions
315            */
316            public java.util.List<LayoutRevision> findByL_H(long layoutSetBranchId,
317                    boolean head);
318    
319            /**
320            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
321            *
322            * <p>
323            * 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 LayoutRevisionModelImpl}. 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.
324            * </p>
325            *
326            * @param layoutSetBranchId the layout set branch ID
327            * @param head the head
328            * @param start the lower bound of the range of layout revisions
329            * @param end the upper bound of the range of layout revisions (not inclusive)
330            * @return the range of matching layout revisions
331            */
332            public java.util.List<LayoutRevision> findByL_H(long layoutSetBranchId,
333                    boolean head, int start, int end);
334    
335            /**
336            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
337            *
338            * <p>
339            * 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 LayoutRevisionModelImpl}. 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.
340            * </p>
341            *
342            * @param layoutSetBranchId the layout set branch ID
343            * @param head the head
344            * @param start the lower bound of the range of layout revisions
345            * @param end the upper bound of the range of layout revisions (not inclusive)
346            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
347            * @return the ordered range of matching layout revisions
348            */
349            public java.util.List<LayoutRevision> findByL_H(long layoutSetBranchId,
350                    boolean head, int start, int end,
351                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
352    
353            /**
354            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
355            *
356            * <p>
357            * 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 LayoutRevisionModelImpl}. 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.
358            * </p>
359            *
360            * @param layoutSetBranchId the layout set branch ID
361            * @param head the head
362            * @param start the lower bound of the range of layout revisions
363            * @param end the upper bound of the range of layout revisions (not inclusive)
364            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
365            * @param retrieveFromCache whether to retrieve from the finder cache
366            * @return the ordered range of matching layout revisions
367            */
368            public java.util.List<LayoutRevision> findByL_H(long layoutSetBranchId,
369                    boolean head, int start, int end,
370                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
371                    boolean retrieveFromCache);
372    
373            /**
374            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
375            *
376            * @param layoutSetBranchId the layout set branch ID
377            * @param head the head
378            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
379            * @return the first matching layout revision
380            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
381            */
382            public LayoutRevision findByL_H_First(long layoutSetBranchId, boolean head,
383                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
384                    throws com.liferay.portal.NoSuchLayoutRevisionException;
385    
386            /**
387            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
388            *
389            * @param layoutSetBranchId the layout set branch ID
390            * @param head the head
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
393            */
394            public LayoutRevision fetchByL_H_First(long layoutSetBranchId,
395                    boolean head,
396                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
397    
398            /**
399            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
400            *
401            * @param layoutSetBranchId the layout set branch ID
402            * @param head the head
403            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
404            * @return the last matching layout revision
405            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
406            */
407            public LayoutRevision findByL_H_Last(long layoutSetBranchId, boolean head,
408                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
409                    throws com.liferay.portal.NoSuchLayoutRevisionException;
410    
411            /**
412            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
413            *
414            * @param layoutSetBranchId the layout set branch ID
415            * @param head the head
416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
417            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
418            */
419            public LayoutRevision fetchByL_H_Last(long layoutSetBranchId, boolean head,
420                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
421    
422            /**
423            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
424            *
425            * @param layoutRevisionId the primary key of the current layout revision
426            * @param layoutSetBranchId the layout set branch ID
427            * @param head the head
428            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
429            * @return the previous, current, and next layout revision
430            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
431            */
432            public LayoutRevision[] findByL_H_PrevAndNext(long layoutRevisionId,
433                    long layoutSetBranchId, boolean head,
434                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
435                    throws com.liferay.portal.NoSuchLayoutRevisionException;
436    
437            /**
438            * Removes all the layout revisions where layoutSetBranchId = &#63; and head = &#63; from the database.
439            *
440            * @param layoutSetBranchId the layout set branch ID
441            * @param head the head
442            */
443            public void removeByL_H(long layoutSetBranchId, boolean head);
444    
445            /**
446            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63;.
447            *
448            * @param layoutSetBranchId the layout set branch ID
449            * @param head the head
450            * @return the number of matching layout revisions
451            */
452            public int countByL_H(long layoutSetBranchId, boolean head);
453    
454            /**
455            * Returns all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
456            *
457            * @param layoutSetBranchId the layout set branch ID
458            * @param plid the plid
459            * @return the matching layout revisions
460            */
461            public java.util.List<LayoutRevision> findByL_P(long layoutSetBranchId,
462                    long plid);
463    
464            /**
465            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
466            *
467            * <p>
468            * 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 LayoutRevisionModelImpl}. 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.
469            * </p>
470            *
471            * @param layoutSetBranchId the layout set branch ID
472            * @param plid the plid
473            * @param start the lower bound of the range of layout revisions
474            * @param end the upper bound of the range of layout revisions (not inclusive)
475            * @return the range of matching layout revisions
476            */
477            public java.util.List<LayoutRevision> findByL_P(long layoutSetBranchId,
478                    long plid, int start, int end);
479    
480            /**
481            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
482            *
483            * <p>
484            * 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 LayoutRevisionModelImpl}. 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.
485            * </p>
486            *
487            * @param layoutSetBranchId the layout set branch ID
488            * @param plid the plid
489            * @param start the lower bound of the range of layout revisions
490            * @param end the upper bound of the range of layout revisions (not inclusive)
491            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
492            * @return the ordered range of matching layout revisions
493            */
494            public java.util.List<LayoutRevision> findByL_P(long layoutSetBranchId,
495                    long plid, int start, int end,
496                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
497    
498            /**
499            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
500            *
501            * <p>
502            * 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 LayoutRevisionModelImpl}. 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.
503            * </p>
504            *
505            * @param layoutSetBranchId the layout set branch ID
506            * @param plid the plid
507            * @param start the lower bound of the range of layout revisions
508            * @param end the upper bound of the range of layout revisions (not inclusive)
509            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
510            * @param retrieveFromCache whether to retrieve from the finder cache
511            * @return the ordered range of matching layout revisions
512            */
513            public java.util.List<LayoutRevision> findByL_P(long layoutSetBranchId,
514                    long plid, int start, int end,
515                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
516                    boolean retrieveFromCache);
517    
518            /**
519            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
520            *
521            * @param layoutSetBranchId the layout set branch ID
522            * @param plid the plid
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the first matching layout revision
525            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
526            */
527            public LayoutRevision findByL_P_First(long layoutSetBranchId, long plid,
528                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
529                    throws com.liferay.portal.NoSuchLayoutRevisionException;
530    
531            /**
532            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
533            *
534            * @param layoutSetBranchId the layout set branch ID
535            * @param plid the plid
536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
537            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
538            */
539            public LayoutRevision fetchByL_P_First(long layoutSetBranchId, long plid,
540                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
541    
542            /**
543            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
544            *
545            * @param layoutSetBranchId the layout set branch ID
546            * @param plid the plid
547            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
548            * @return the last matching layout revision
549            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
550            */
551            public LayoutRevision findByL_P_Last(long layoutSetBranchId, long plid,
552                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
553                    throws com.liferay.portal.NoSuchLayoutRevisionException;
554    
555            /**
556            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
557            *
558            * @param layoutSetBranchId the layout set branch ID
559            * @param plid the plid
560            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
561            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
562            */
563            public LayoutRevision fetchByL_P_Last(long layoutSetBranchId, long plid,
564                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
565    
566            /**
567            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
568            *
569            * @param layoutRevisionId the primary key of the current layout revision
570            * @param layoutSetBranchId the layout set branch ID
571            * @param plid the plid
572            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
573            * @return the previous, current, and next layout revision
574            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
575            */
576            public LayoutRevision[] findByL_P_PrevAndNext(long layoutRevisionId,
577                    long layoutSetBranchId, long plid,
578                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
579                    throws com.liferay.portal.NoSuchLayoutRevisionException;
580    
581            /**
582            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; from the database.
583            *
584            * @param layoutSetBranchId the layout set branch ID
585            * @param plid the plid
586            */
587            public void removeByL_P(long layoutSetBranchId, long plid);
588    
589            /**
590            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
591            *
592            * @param layoutSetBranchId the layout set branch ID
593            * @param plid the plid
594            * @return the number of matching layout revisions
595            */
596            public int countByL_P(long layoutSetBranchId, long plid);
597    
598            /**
599            * Returns all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
600            *
601            * @param layoutSetBranchId the layout set branch ID
602            * @param status the status
603            * @return the matching layout revisions
604            */
605            public java.util.List<LayoutRevision> findByL_S(long layoutSetBranchId,
606                    int status);
607    
608            /**
609            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
610            *
611            * <p>
612            * 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 LayoutRevisionModelImpl}. 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.
613            * </p>
614            *
615            * @param layoutSetBranchId the layout set branch ID
616            * @param status the status
617            * @param start the lower bound of the range of layout revisions
618            * @param end the upper bound of the range of layout revisions (not inclusive)
619            * @return the range of matching layout revisions
620            */
621            public java.util.List<LayoutRevision> findByL_S(long layoutSetBranchId,
622                    int status, int start, int end);
623    
624            /**
625            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
626            *
627            * <p>
628            * 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 LayoutRevisionModelImpl}. 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.
629            * </p>
630            *
631            * @param layoutSetBranchId the layout set branch ID
632            * @param status the status
633            * @param start the lower bound of the range of layout revisions
634            * @param end the upper bound of the range of layout revisions (not inclusive)
635            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
636            * @return the ordered range of matching layout revisions
637            */
638            public java.util.List<LayoutRevision> findByL_S(long layoutSetBranchId,
639                    int status, int start, int end,
640                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
641    
642            /**
643            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
644            *
645            * <p>
646            * 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 LayoutRevisionModelImpl}. 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.
647            * </p>
648            *
649            * @param layoutSetBranchId the layout set branch ID
650            * @param status the status
651            * @param start the lower bound of the range of layout revisions
652            * @param end the upper bound of the range of layout revisions (not inclusive)
653            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
654            * @param retrieveFromCache whether to retrieve from the finder cache
655            * @return the ordered range of matching layout revisions
656            */
657            public java.util.List<LayoutRevision> findByL_S(long layoutSetBranchId,
658                    int status, int start, int end,
659                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
660                    boolean retrieveFromCache);
661    
662            /**
663            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
664            *
665            * @param layoutSetBranchId the layout set branch ID
666            * @param status the status
667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
668            * @return the first matching layout revision
669            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
670            */
671            public LayoutRevision findByL_S_First(long layoutSetBranchId, int status,
672                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
673                    throws com.liferay.portal.NoSuchLayoutRevisionException;
674    
675            /**
676            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
677            *
678            * @param layoutSetBranchId the layout set branch ID
679            * @param status the status
680            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
681            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
682            */
683            public LayoutRevision fetchByL_S_First(long layoutSetBranchId, int status,
684                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
685    
686            /**
687            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
688            *
689            * @param layoutSetBranchId the layout set branch ID
690            * @param status the status
691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
692            * @return the last matching layout revision
693            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
694            */
695            public LayoutRevision findByL_S_Last(long layoutSetBranchId, int status,
696                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
697                    throws com.liferay.portal.NoSuchLayoutRevisionException;
698    
699            /**
700            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
701            *
702            * @param layoutSetBranchId the layout set branch ID
703            * @param status the status
704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
705            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
706            */
707            public LayoutRevision fetchByL_S_Last(long layoutSetBranchId, int status,
708                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
709    
710            /**
711            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
712            *
713            * @param layoutRevisionId the primary key of the current layout revision
714            * @param layoutSetBranchId the layout set branch ID
715            * @param status the status
716            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
717            * @return the previous, current, and next layout revision
718            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
719            */
720            public LayoutRevision[] findByL_S_PrevAndNext(long layoutRevisionId,
721                    long layoutSetBranchId, int status,
722                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
723                    throws com.liferay.portal.NoSuchLayoutRevisionException;
724    
725            /**
726            * Removes all the layout revisions where layoutSetBranchId = &#63; and status = &#63; from the database.
727            *
728            * @param layoutSetBranchId the layout set branch ID
729            * @param status the status
730            */
731            public void removeByL_S(long layoutSetBranchId, int status);
732    
733            /**
734            * Returns the number of layout revisions where layoutSetBranchId = &#63; and status = &#63;.
735            *
736            * @param layoutSetBranchId the layout set branch ID
737            * @param status the status
738            * @return the number of matching layout revisions
739            */
740            public int countByL_S(long layoutSetBranchId, int status);
741    
742            /**
743            * Returns all the layout revisions where head = &#63; and plid = &#63;.
744            *
745            * @param head the head
746            * @param plid the plid
747            * @return the matching layout revisions
748            */
749            public java.util.List<LayoutRevision> findByH_P(boolean head, long plid);
750    
751            /**
752            * Returns a range of all the layout revisions where head = &#63; and plid = &#63;.
753            *
754            * <p>
755            * 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 LayoutRevisionModelImpl}. 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.
756            * </p>
757            *
758            * @param head the head
759            * @param plid the plid
760            * @param start the lower bound of the range of layout revisions
761            * @param end the upper bound of the range of layout revisions (not inclusive)
762            * @return the range of matching layout revisions
763            */
764            public java.util.List<LayoutRevision> findByH_P(boolean head, long plid,
765                    int start, int end);
766    
767            /**
768            * Returns an ordered range of all the layout revisions where head = &#63; and plid = &#63;.
769            *
770            * <p>
771            * 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 LayoutRevisionModelImpl}. 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.
772            * </p>
773            *
774            * @param head the head
775            * @param plid the plid
776            * @param start the lower bound of the range of layout revisions
777            * @param end the upper bound of the range of layout revisions (not inclusive)
778            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
779            * @return the ordered range of matching layout revisions
780            */
781            public java.util.List<LayoutRevision> findByH_P(boolean head, long plid,
782                    int start, int end,
783                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
784    
785            /**
786            * Returns an ordered range of all the layout revisions where head = &#63; and plid = &#63;.
787            *
788            * <p>
789            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutRevisionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
790            * </p>
791            *
792            * @param head the head
793            * @param plid the plid
794            * @param start the lower bound of the range of layout revisions
795            * @param end the upper bound of the range of layout revisions (not inclusive)
796            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
797            * @param retrieveFromCache whether to retrieve from the finder cache
798            * @return the ordered range of matching layout revisions
799            */
800            public java.util.List<LayoutRevision> findByH_P(boolean head, long plid,
801                    int start, int end,
802                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
803                    boolean retrieveFromCache);
804    
805            /**
806            * Returns the first layout revision in the ordered set where head = &#63; and plid = &#63;.
807            *
808            * @param head the head
809            * @param plid the plid
810            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
811            * @return the first matching layout revision
812            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
813            */
814            public LayoutRevision findByH_P_First(boolean head, long plid,
815                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
816                    throws com.liferay.portal.NoSuchLayoutRevisionException;
817    
818            /**
819            * Returns the first layout revision in the ordered set where head = &#63; and plid = &#63;.
820            *
821            * @param head the head
822            * @param plid the plid
823            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
824            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
825            */
826            public LayoutRevision fetchByH_P_First(boolean head, long plid,
827                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
828    
829            /**
830            * Returns the last layout revision in the ordered set where head = &#63; and plid = &#63;.
831            *
832            * @param head the head
833            * @param plid the plid
834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
835            * @return the last matching layout revision
836            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
837            */
838            public LayoutRevision findByH_P_Last(boolean head, long plid,
839                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
840                    throws com.liferay.portal.NoSuchLayoutRevisionException;
841    
842            /**
843            * Returns the last layout revision in the ordered set where head = &#63; and plid = &#63;.
844            *
845            * @param head the head
846            * @param plid the plid
847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
848            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
849            */
850            public LayoutRevision fetchByH_P_Last(boolean head, long plid,
851                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
852    
853            /**
854            * Returns the layout revisions before and after the current layout revision in the ordered set where head = &#63; and plid = &#63;.
855            *
856            * @param layoutRevisionId the primary key of the current layout revision
857            * @param head the head
858            * @param plid the plid
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the previous, current, and next layout revision
861            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
862            */
863            public LayoutRevision[] findByH_P_PrevAndNext(long layoutRevisionId,
864                    boolean head, long plid,
865                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
866                    throws com.liferay.portal.NoSuchLayoutRevisionException;
867    
868            /**
869            * Removes all the layout revisions where head = &#63; and plid = &#63; from the database.
870            *
871            * @param head the head
872            * @param plid the plid
873            */
874            public void removeByH_P(boolean head, long plid);
875    
876            /**
877            * Returns the number of layout revisions where head = &#63; and plid = &#63;.
878            *
879            * @param head the head
880            * @param plid the plid
881            * @return the number of matching layout revisions
882            */
883            public int countByH_P(boolean head, long plid);
884    
885            /**
886            * Returns all the layout revisions where plid = &#63; and status &ne; &#63;.
887            *
888            * @param plid the plid
889            * @param status the status
890            * @return the matching layout revisions
891            */
892            public java.util.List<LayoutRevision> findByP_NotS(long plid, int status);
893    
894            /**
895            * Returns a range of all the layout revisions where plid = &#63; and status &ne; &#63;.
896            *
897            * <p>
898            * 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 LayoutRevisionModelImpl}. 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.
899            * </p>
900            *
901            * @param plid the plid
902            * @param status the status
903            * @param start the lower bound of the range of layout revisions
904            * @param end the upper bound of the range of layout revisions (not inclusive)
905            * @return the range of matching layout revisions
906            */
907            public java.util.List<LayoutRevision> findByP_NotS(long plid, int status,
908                    int start, int end);
909    
910            /**
911            * Returns an ordered range of all the layout revisions where plid = &#63; and status &ne; &#63;.
912            *
913            * <p>
914            * 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 LayoutRevisionModelImpl}. 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.
915            * </p>
916            *
917            * @param plid the plid
918            * @param status the status
919            * @param start the lower bound of the range of layout revisions
920            * @param end the upper bound of the range of layout revisions (not inclusive)
921            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
922            * @return the ordered range of matching layout revisions
923            */
924            public java.util.List<LayoutRevision> findByP_NotS(long plid, int status,
925                    int start, int end,
926                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
927    
928            /**
929            * Returns an ordered range of all the layout revisions where plid = &#63; and status &ne; &#63;.
930            *
931            * <p>
932            * 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 LayoutRevisionModelImpl}. 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.
933            * </p>
934            *
935            * @param plid the plid
936            * @param status the status
937            * @param start the lower bound of the range of layout revisions
938            * @param end the upper bound of the range of layout revisions (not inclusive)
939            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
940            * @param retrieveFromCache whether to retrieve from the finder cache
941            * @return the ordered range of matching layout revisions
942            */
943            public java.util.List<LayoutRevision> findByP_NotS(long plid, int status,
944                    int start, int end,
945                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
946                    boolean retrieveFromCache);
947    
948            /**
949            * Returns the first layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
950            *
951            * @param plid the plid
952            * @param status the status
953            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
954            * @return the first matching layout revision
955            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
956            */
957            public LayoutRevision findByP_NotS_First(long plid, int status,
958                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
959                    throws com.liferay.portal.NoSuchLayoutRevisionException;
960    
961            /**
962            * Returns the first layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
963            *
964            * @param plid the plid
965            * @param status the status
966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
967            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
968            */
969            public LayoutRevision fetchByP_NotS_First(long plid, int status,
970                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
971    
972            /**
973            * Returns the last layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
974            *
975            * @param plid the plid
976            * @param status the status
977            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
978            * @return the last matching layout revision
979            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
980            */
981            public LayoutRevision findByP_NotS_Last(long plid, int status,
982                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
983                    throws com.liferay.portal.NoSuchLayoutRevisionException;
984    
985            /**
986            * Returns the last layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
987            *
988            * @param plid the plid
989            * @param status the status
990            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
991            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
992            */
993            public LayoutRevision fetchByP_NotS_Last(long plid, int status,
994                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
995    
996            /**
997            * Returns the layout revisions before and after the current layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
998            *
999            * @param layoutRevisionId the primary key of the current layout revision
1000            * @param plid the plid
1001            * @param status the status
1002            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1003            * @return the previous, current, and next layout revision
1004            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1005            */
1006            public LayoutRevision[] findByP_NotS_PrevAndNext(long layoutRevisionId,
1007                    long plid, int status,
1008                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1009                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1010    
1011            /**
1012            * Removes all the layout revisions where plid = &#63; and status &ne; &#63; from the database.
1013            *
1014            * @param plid the plid
1015            * @param status the status
1016            */
1017            public void removeByP_NotS(long plid, int status);
1018    
1019            /**
1020            * Returns the number of layout revisions where plid = &#63; and status &ne; &#63;.
1021            *
1022            * @param plid the plid
1023            * @param status the status
1024            * @return the number of matching layout revisions
1025            */
1026            public int countByP_NotS(long plid, int status);
1027    
1028            /**
1029            * Returns all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1030            *
1031            * @param layoutSetBranchId the layout set branch ID
1032            * @param layoutBranchId the layout branch ID
1033            * @param plid the plid
1034            * @return the matching layout revisions
1035            */
1036            public java.util.List<LayoutRevision> findByL_L_P(long layoutSetBranchId,
1037                    long layoutBranchId, long plid);
1038    
1039            /**
1040            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1041            *
1042            * <p>
1043            * 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 LayoutRevisionModelImpl}. 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.
1044            * </p>
1045            *
1046            * @param layoutSetBranchId the layout set branch ID
1047            * @param layoutBranchId the layout branch ID
1048            * @param plid the plid
1049            * @param start the lower bound of the range of layout revisions
1050            * @param end the upper bound of the range of layout revisions (not inclusive)
1051            * @return the range of matching layout revisions
1052            */
1053            public java.util.List<LayoutRevision> findByL_L_P(long layoutSetBranchId,
1054                    long layoutBranchId, long plid, int start, int end);
1055    
1056            /**
1057            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1058            *
1059            * <p>
1060            * 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 LayoutRevisionModelImpl}. 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.
1061            * </p>
1062            *
1063            * @param layoutSetBranchId the layout set branch ID
1064            * @param layoutBranchId the layout branch ID
1065            * @param plid the plid
1066            * @param start the lower bound of the range of layout revisions
1067            * @param end the upper bound of the range of layout revisions (not inclusive)
1068            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1069            * @return the ordered range of matching layout revisions
1070            */
1071            public java.util.List<LayoutRevision> findByL_L_P(long layoutSetBranchId,
1072                    long layoutBranchId, long plid, int start, int end,
1073                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1074    
1075            /**
1076            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1077            *
1078            * <p>
1079            * 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 LayoutRevisionModelImpl}. 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.
1080            * </p>
1081            *
1082            * @param layoutSetBranchId the layout set branch ID
1083            * @param layoutBranchId the layout branch ID
1084            * @param plid the plid
1085            * @param start the lower bound of the range of layout revisions
1086            * @param end the upper bound of the range of layout revisions (not inclusive)
1087            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1088            * @param retrieveFromCache whether to retrieve from the finder cache
1089            * @return the ordered range of matching layout revisions
1090            */
1091            public java.util.List<LayoutRevision> findByL_L_P(long layoutSetBranchId,
1092                    long layoutBranchId, long plid, int start, int end,
1093                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
1094                    boolean retrieveFromCache);
1095    
1096            /**
1097            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1098            *
1099            * @param layoutSetBranchId the layout set branch ID
1100            * @param layoutBranchId the layout branch ID
1101            * @param plid the plid
1102            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1103            * @return the first matching layout revision
1104            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1105            */
1106            public LayoutRevision findByL_L_P_First(long layoutSetBranchId,
1107                    long layoutBranchId, long plid,
1108                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1109                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1110    
1111            /**
1112            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1113            *
1114            * @param layoutSetBranchId the layout set branch ID
1115            * @param layoutBranchId the layout branch ID
1116            * @param plid the plid
1117            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1118            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1119            */
1120            public LayoutRevision fetchByL_L_P_First(long layoutSetBranchId,
1121                    long layoutBranchId, long plid,
1122                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1123    
1124            /**
1125            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1126            *
1127            * @param layoutSetBranchId the layout set branch ID
1128            * @param layoutBranchId the layout branch ID
1129            * @param plid the plid
1130            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1131            * @return the last matching layout revision
1132            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1133            */
1134            public LayoutRevision findByL_L_P_Last(long layoutSetBranchId,
1135                    long layoutBranchId, long plid,
1136                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1137                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1138    
1139            /**
1140            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1141            *
1142            * @param layoutSetBranchId the layout set branch ID
1143            * @param layoutBranchId the layout branch ID
1144            * @param plid the plid
1145            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1146            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1147            */
1148            public LayoutRevision fetchByL_L_P_Last(long layoutSetBranchId,
1149                    long layoutBranchId, long plid,
1150                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1151    
1152            /**
1153            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1154            *
1155            * @param layoutRevisionId the primary key of the current layout revision
1156            * @param layoutSetBranchId the layout set branch ID
1157            * @param layoutBranchId the layout branch ID
1158            * @param plid the plid
1159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1160            * @return the previous, current, and next layout revision
1161            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1162            */
1163            public LayoutRevision[] findByL_L_P_PrevAndNext(long layoutRevisionId,
1164                    long layoutSetBranchId, long layoutBranchId, long plid,
1165                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1166                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1167    
1168            /**
1169            * Removes all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63; from the database.
1170            *
1171            * @param layoutSetBranchId the layout set branch ID
1172            * @param layoutBranchId the layout branch ID
1173            * @param plid the plid
1174            */
1175            public void removeByL_L_P(long layoutSetBranchId, long layoutBranchId,
1176                    long plid);
1177    
1178            /**
1179            * Returns the number of layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1180            *
1181            * @param layoutSetBranchId the layout set branch ID
1182            * @param layoutBranchId the layout branch ID
1183            * @param plid the plid
1184            * @return the number of matching layout revisions
1185            */
1186            public int countByL_L_P(long layoutSetBranchId, long layoutBranchId,
1187                    long plid);
1188    
1189            /**
1190            * Returns all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1191            *
1192            * @param layoutSetBranchId the layout set branch ID
1193            * @param parentLayoutRevisionId the parent layout revision ID
1194            * @param plid the plid
1195            * @return the matching layout revisions
1196            */
1197            public java.util.List<LayoutRevision> findByL_P_P(long layoutSetBranchId,
1198                    long parentLayoutRevisionId, long plid);
1199    
1200            /**
1201            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1202            *
1203            * <p>
1204            * 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 LayoutRevisionModelImpl}. 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.
1205            * </p>
1206            *
1207            * @param layoutSetBranchId the layout set branch ID
1208            * @param parentLayoutRevisionId the parent layout revision ID
1209            * @param plid the plid
1210            * @param start the lower bound of the range of layout revisions
1211            * @param end the upper bound of the range of layout revisions (not inclusive)
1212            * @return the range of matching layout revisions
1213            */
1214            public java.util.List<LayoutRevision> findByL_P_P(long layoutSetBranchId,
1215                    long parentLayoutRevisionId, long plid, int start, int end);
1216    
1217            /**
1218            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1219            *
1220            * <p>
1221            * 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 LayoutRevisionModelImpl}. 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.
1222            * </p>
1223            *
1224            * @param layoutSetBranchId the layout set branch ID
1225            * @param parentLayoutRevisionId the parent layout revision ID
1226            * @param plid the plid
1227            * @param start the lower bound of the range of layout revisions
1228            * @param end the upper bound of the range of layout revisions (not inclusive)
1229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1230            * @return the ordered range of matching layout revisions
1231            */
1232            public java.util.List<LayoutRevision> findByL_P_P(long layoutSetBranchId,
1233                    long parentLayoutRevisionId, long plid, int start, int end,
1234                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1235    
1236            /**
1237            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1238            *
1239            * <p>
1240            * 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 LayoutRevisionModelImpl}. 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.
1241            * </p>
1242            *
1243            * @param layoutSetBranchId the layout set branch ID
1244            * @param parentLayoutRevisionId the parent layout revision ID
1245            * @param plid the plid
1246            * @param start the lower bound of the range of layout revisions
1247            * @param end the upper bound of the range of layout revisions (not inclusive)
1248            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1249            * @param retrieveFromCache whether to retrieve from the finder cache
1250            * @return the ordered range of matching layout revisions
1251            */
1252            public java.util.List<LayoutRevision> findByL_P_P(long layoutSetBranchId,
1253                    long parentLayoutRevisionId, long plid, int start, int end,
1254                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
1255                    boolean retrieveFromCache);
1256    
1257            /**
1258            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1259            *
1260            * @param layoutSetBranchId the layout set branch ID
1261            * @param parentLayoutRevisionId the parent layout revision ID
1262            * @param plid the plid
1263            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1264            * @return the first matching layout revision
1265            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1266            */
1267            public LayoutRevision findByL_P_P_First(long layoutSetBranchId,
1268                    long parentLayoutRevisionId, long plid,
1269                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1270                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1271    
1272            /**
1273            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1274            *
1275            * @param layoutSetBranchId the layout set branch ID
1276            * @param parentLayoutRevisionId the parent layout revision ID
1277            * @param plid the plid
1278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1279            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1280            */
1281            public LayoutRevision fetchByL_P_P_First(long layoutSetBranchId,
1282                    long parentLayoutRevisionId, long plid,
1283                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1284    
1285            /**
1286            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1287            *
1288            * @param layoutSetBranchId the layout set branch ID
1289            * @param parentLayoutRevisionId the parent layout revision ID
1290            * @param plid the plid
1291            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1292            * @return the last matching layout revision
1293            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1294            */
1295            public LayoutRevision findByL_P_P_Last(long layoutSetBranchId,
1296                    long parentLayoutRevisionId, long plid,
1297                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1298                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1299    
1300            /**
1301            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1302            *
1303            * @param layoutSetBranchId the layout set branch ID
1304            * @param parentLayoutRevisionId the parent layout revision ID
1305            * @param plid the plid
1306            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1307            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1308            */
1309            public LayoutRevision fetchByL_P_P_Last(long layoutSetBranchId,
1310                    long parentLayoutRevisionId, long plid,
1311                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1312    
1313            /**
1314            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1315            *
1316            * @param layoutRevisionId the primary key of the current layout revision
1317            * @param layoutSetBranchId the layout set branch ID
1318            * @param parentLayoutRevisionId the parent layout revision ID
1319            * @param plid the plid
1320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1321            * @return the previous, current, and next layout revision
1322            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1323            */
1324            public LayoutRevision[] findByL_P_P_PrevAndNext(long layoutRevisionId,
1325                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1326                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1327                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1328    
1329            /**
1330            * Removes all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63; from the database.
1331            *
1332            * @param layoutSetBranchId the layout set branch ID
1333            * @param parentLayoutRevisionId the parent layout revision ID
1334            * @param plid the plid
1335            */
1336            public void removeByL_P_P(long layoutSetBranchId,
1337                    long parentLayoutRevisionId, long plid);
1338    
1339            /**
1340            * Returns the number of layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1341            *
1342            * @param layoutSetBranchId the layout set branch ID
1343            * @param parentLayoutRevisionId the parent layout revision ID
1344            * @param plid the plid
1345            * @return the number of matching layout revisions
1346            */
1347            public int countByL_P_P(long layoutSetBranchId,
1348                    long parentLayoutRevisionId, long plid);
1349    
1350            /**
1351            * Returns the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; or throws a {@link NoSuchLayoutRevisionException} if it could not be found.
1352            *
1353            * @param layoutSetBranchId the layout set branch ID
1354            * @param head the head
1355            * @param plid the plid
1356            * @return the matching layout revision
1357            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1358            */
1359            public LayoutRevision findByL_H_P(long layoutSetBranchId, boolean head,
1360                    long plid) throws com.liferay.portal.NoSuchLayoutRevisionException;
1361    
1362            /**
1363            * Returns the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1364            *
1365            * @param layoutSetBranchId the layout set branch ID
1366            * @param head the head
1367            * @param plid the plid
1368            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1369            */
1370            public LayoutRevision fetchByL_H_P(long layoutSetBranchId, boolean head,
1371                    long plid);
1372    
1373            /**
1374            * Returns the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1375            *
1376            * @param layoutSetBranchId the layout set branch ID
1377            * @param head the head
1378            * @param plid the plid
1379            * @param retrieveFromCache whether to retrieve from the finder cache
1380            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1381            */
1382            public LayoutRevision fetchByL_H_P(long layoutSetBranchId, boolean head,
1383                    long plid, boolean retrieveFromCache);
1384    
1385            /**
1386            * Removes the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; from the database.
1387            *
1388            * @param layoutSetBranchId the layout set branch ID
1389            * @param head the head
1390            * @param plid the plid
1391            * @return the layout revision that was removed
1392            */
1393            public LayoutRevision removeByL_H_P(long layoutSetBranchId, boolean head,
1394                    long plid) throws com.liferay.portal.NoSuchLayoutRevisionException;
1395    
1396            /**
1397            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63; and plid = &#63;.
1398            *
1399            * @param layoutSetBranchId the layout set branch ID
1400            * @param head the head
1401            * @param plid the plid
1402            * @return the number of matching layout revisions
1403            */
1404            public int countByL_H_P(long layoutSetBranchId, boolean head, long plid);
1405    
1406            /**
1407            * Returns all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1408            *
1409            * @param layoutSetBranchId the layout set branch ID
1410            * @param plid the plid
1411            * @param status the status
1412            * @return the matching layout revisions
1413            */
1414            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1415                    long plid, int status);
1416    
1417            /**
1418            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1419            *
1420            * <p>
1421            * 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 LayoutRevisionModelImpl}. 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.
1422            * </p>
1423            *
1424            * @param layoutSetBranchId the layout set branch ID
1425            * @param plid the plid
1426            * @param status the status
1427            * @param start the lower bound of the range of layout revisions
1428            * @param end the upper bound of the range of layout revisions (not inclusive)
1429            * @return the range of matching layout revisions
1430            */
1431            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1432                    long plid, int status, int start, int end);
1433    
1434            /**
1435            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1436            *
1437            * <p>
1438            * 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 LayoutRevisionModelImpl}. 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.
1439            * </p>
1440            *
1441            * @param layoutSetBranchId the layout set branch ID
1442            * @param plid the plid
1443            * @param status the status
1444            * @param start the lower bound of the range of layout revisions
1445            * @param end the upper bound of the range of layout revisions (not inclusive)
1446            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1447            * @return the ordered range of matching layout revisions
1448            */
1449            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1450                    long plid, int status, int start, int end,
1451                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1452    
1453            /**
1454            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1455            *
1456            * <p>
1457            * 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 LayoutRevisionModelImpl}. 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.
1458            * </p>
1459            *
1460            * @param layoutSetBranchId the layout set branch ID
1461            * @param plid the plid
1462            * @param status the status
1463            * @param start the lower bound of the range of layout revisions
1464            * @param end the upper bound of the range of layout revisions (not inclusive)
1465            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1466            * @param retrieveFromCache whether to retrieve from the finder cache
1467            * @return the ordered range of matching layout revisions
1468            */
1469            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1470                    long plid, int status, int start, int end,
1471                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
1472                    boolean retrieveFromCache);
1473    
1474            /**
1475            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1476            *
1477            * @param layoutSetBranchId the layout set branch ID
1478            * @param plid the plid
1479            * @param status the status
1480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1481            * @return the first matching layout revision
1482            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1483            */
1484            public LayoutRevision findByL_P_S_First(long layoutSetBranchId, long plid,
1485                    int status,
1486                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1487                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1488    
1489            /**
1490            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1491            *
1492            * @param layoutSetBranchId the layout set branch ID
1493            * @param plid the plid
1494            * @param status the status
1495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1496            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1497            */
1498            public LayoutRevision fetchByL_P_S_First(long layoutSetBranchId, long plid,
1499                    int status,
1500                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1501    
1502            /**
1503            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1504            *
1505            * @param layoutSetBranchId the layout set branch ID
1506            * @param plid the plid
1507            * @param status the status
1508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1509            * @return the last matching layout revision
1510            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1511            */
1512            public LayoutRevision findByL_P_S_Last(long layoutSetBranchId, long plid,
1513                    int status,
1514                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1515                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1516    
1517            /**
1518            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1519            *
1520            * @param layoutSetBranchId the layout set branch ID
1521            * @param plid the plid
1522            * @param status the status
1523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1524            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1525            */
1526            public LayoutRevision fetchByL_P_S_Last(long layoutSetBranchId, long plid,
1527                    int status,
1528                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1529    
1530            /**
1531            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1532            *
1533            * @param layoutRevisionId the primary key of the current layout revision
1534            * @param layoutSetBranchId the layout set branch ID
1535            * @param plid the plid
1536            * @param status the status
1537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1538            * @return the previous, current, and next layout revision
1539            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1540            */
1541            public LayoutRevision[] findByL_P_S_PrevAndNext(long layoutRevisionId,
1542                    long layoutSetBranchId, long plid, int status,
1543                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1544                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1545    
1546            /**
1547            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63; from the database.
1548            *
1549            * @param layoutSetBranchId the layout set branch ID
1550            * @param plid the plid
1551            * @param status the status
1552            */
1553            public void removeByL_P_S(long layoutSetBranchId, long plid, int status);
1554    
1555            /**
1556            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1557            *
1558            * @param layoutSetBranchId the layout set branch ID
1559            * @param plid the plid
1560            * @param status the status
1561            * @return the number of matching layout revisions
1562            */
1563            public int countByL_P_S(long layoutSetBranchId, long plid, int status);
1564    
1565            /**
1566            * Caches the layout revision in the entity cache if it is enabled.
1567            *
1568            * @param layoutRevision the layout revision
1569            */
1570            public void cacheResult(LayoutRevision layoutRevision);
1571    
1572            /**
1573            * Caches the layout revisions in the entity cache if it is enabled.
1574            *
1575            * @param layoutRevisions the layout revisions
1576            */
1577            public void cacheResult(java.util.List<LayoutRevision> layoutRevisions);
1578    
1579            /**
1580            * Creates a new layout revision with the primary key. Does not add the layout revision to the database.
1581            *
1582            * @param layoutRevisionId the primary key for the new layout revision
1583            * @return the new layout revision
1584            */
1585            public LayoutRevision create(long layoutRevisionId);
1586    
1587            /**
1588            * Removes the layout revision with the primary key from the database. Also notifies the appropriate model listeners.
1589            *
1590            * @param layoutRevisionId the primary key of the layout revision
1591            * @return the layout revision that was removed
1592            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1593            */
1594            public LayoutRevision remove(long layoutRevisionId)
1595                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1596    
1597            public LayoutRevision updateImpl(LayoutRevision layoutRevision);
1598    
1599            /**
1600            * Returns the layout revision with the primary key or throws a {@link NoSuchLayoutRevisionException} if it could not be found.
1601            *
1602            * @param layoutRevisionId the primary key of the layout revision
1603            * @return the layout revision
1604            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1605            */
1606            public LayoutRevision findByPrimaryKey(long layoutRevisionId)
1607                    throws com.liferay.portal.NoSuchLayoutRevisionException;
1608    
1609            /**
1610            * Returns the layout revision with the primary key or returns <code>null</code> if it could not be found.
1611            *
1612            * @param layoutRevisionId the primary key of the layout revision
1613            * @return the layout revision, or <code>null</code> if a layout revision with the primary key could not be found
1614            */
1615            public LayoutRevision fetchByPrimaryKey(long layoutRevisionId);
1616    
1617            @Override
1618            public java.util.Map<java.io.Serializable, LayoutRevision> fetchByPrimaryKeys(
1619                    java.util.Set<java.io.Serializable> primaryKeys);
1620    
1621            /**
1622            * Returns all the layout revisions.
1623            *
1624            * @return the layout revisions
1625            */
1626            public java.util.List<LayoutRevision> findAll();
1627    
1628            /**
1629            * Returns a range of all the layout revisions.
1630            *
1631            * <p>
1632            * 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 LayoutRevisionModelImpl}. 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.
1633            * </p>
1634            *
1635            * @param start the lower bound of the range of layout revisions
1636            * @param end the upper bound of the range of layout revisions (not inclusive)
1637            * @return the range of layout revisions
1638            */
1639            public java.util.List<LayoutRevision> findAll(int start, int end);
1640    
1641            /**
1642            * Returns an ordered range of all the layout revisions.
1643            *
1644            * <p>
1645            * 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 LayoutRevisionModelImpl}. 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.
1646            * </p>
1647            *
1648            * @param start the lower bound of the range of layout revisions
1649            * @param end the upper bound of the range of layout revisions (not inclusive)
1650            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1651            * @return the ordered range of layout revisions
1652            */
1653            public java.util.List<LayoutRevision> findAll(int start, int end,
1654                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1655    
1656            /**
1657            * Returns an ordered range of all the layout revisions.
1658            *
1659            * <p>
1660            * 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 LayoutRevisionModelImpl}. 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.
1661            * </p>
1662            *
1663            * @param start the lower bound of the range of layout revisions
1664            * @param end the upper bound of the range of layout revisions (not inclusive)
1665            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1666            * @param retrieveFromCache whether to retrieve from the finder cache
1667            * @return the ordered range of layout revisions
1668            */
1669            public java.util.List<LayoutRevision> findAll(int start, int end,
1670                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
1671                    boolean retrieveFromCache);
1672    
1673            /**
1674            * Removes all the layout revisions from the database.
1675            */
1676            public void removeAll();
1677    
1678            /**
1679            * Returns the number of layout revisions.
1680            *
1681            * @return the number of layout revisions
1682            */
1683            public int countAll();
1684    }