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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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)
1361                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1362    
1363            /**
1364            * 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.
1365            *
1366            * @param layoutSetBranchId the layout set branch ID
1367            * @param head the head
1368            * @param plid the plid
1369            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1370            */
1371            public LayoutRevision fetchByL_H_P(long layoutSetBranchId, boolean head,
1372                    long plid);
1373    
1374            /**
1375            * 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.
1376            *
1377            * @param layoutSetBranchId the layout set branch ID
1378            * @param head the head
1379            * @param plid the plid
1380            * @param retrieveFromCache whether to retrieve from the finder cache
1381            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1382            */
1383            public LayoutRevision fetchByL_H_P(long layoutSetBranchId, boolean head,
1384                    long plid, boolean retrieveFromCache);
1385    
1386            /**
1387            * Removes the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; from the database.
1388            *
1389            * @param layoutSetBranchId the layout set branch ID
1390            * @param head the head
1391            * @param plid the plid
1392            * @return the layout revision that was removed
1393            */
1394            public LayoutRevision removeByL_H_P(long layoutSetBranchId, boolean head,
1395                    long plid)
1396                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1397    
1398            /**
1399            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63; and plid = &#63;.
1400            *
1401            * @param layoutSetBranchId the layout set branch ID
1402            * @param head the head
1403            * @param plid the plid
1404            * @return the number of matching layout revisions
1405            */
1406            public int countByL_H_P(long layoutSetBranchId, boolean head, long plid);
1407    
1408            /**
1409            * Returns all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1410            *
1411            * @param layoutSetBranchId the layout set branch ID
1412            * @param plid the plid
1413            * @param status the status
1414            * @return the matching layout revisions
1415            */
1416            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1417                    long plid, int status);
1418    
1419            /**
1420            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1421            *
1422            * <p>
1423            * 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.
1424            * </p>
1425            *
1426            * @param layoutSetBranchId the layout set branch ID
1427            * @param plid the plid
1428            * @param status the status
1429            * @param start the lower bound of the range of layout revisions
1430            * @param end the upper bound of the range of layout revisions (not inclusive)
1431            * @return the range of matching layout revisions
1432            */
1433            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1434                    long plid, int status, int start, int end);
1435    
1436            /**
1437            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1438            *
1439            * <p>
1440            * 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.
1441            * </p>
1442            *
1443            * @param layoutSetBranchId the layout set branch ID
1444            * @param plid the plid
1445            * @param status the status
1446            * @param start the lower bound of the range of layout revisions
1447            * @param end the upper bound of the range of layout revisions (not inclusive)
1448            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1449            * @return the ordered range of matching layout revisions
1450            */
1451            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1452                    long plid, int status, int start, int end,
1453                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1454    
1455            /**
1456            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1457            *
1458            * <p>
1459            * 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.
1460            * </p>
1461            *
1462            * @param layoutSetBranchId the layout set branch ID
1463            * @param plid the plid
1464            * @param status the status
1465            * @param start the lower bound of the range of layout revisions
1466            * @param end the upper bound of the range of layout revisions (not inclusive)
1467            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1468            * @param retrieveFromCache whether to retrieve from the finder cache
1469            * @return the ordered range of matching layout revisions
1470            */
1471            public java.util.List<LayoutRevision> findByL_P_S(long layoutSetBranchId,
1472                    long plid, int status, int start, int end,
1473                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
1474                    boolean retrieveFromCache);
1475    
1476            /**
1477            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1478            *
1479            * @param layoutSetBranchId the layout set branch ID
1480            * @param plid the plid
1481            * @param status the status
1482            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1483            * @return the first matching layout revision
1484            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1485            */
1486            public LayoutRevision findByL_P_S_First(long layoutSetBranchId, long plid,
1487                    int status,
1488                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1489                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1490    
1491            /**
1492            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1493            *
1494            * @param layoutSetBranchId the layout set branch ID
1495            * @param plid the plid
1496            * @param status the status
1497            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1498            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1499            */
1500            public LayoutRevision fetchByL_P_S_First(long layoutSetBranchId, long plid,
1501                    int status,
1502                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1503    
1504            /**
1505            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1506            *
1507            * @param layoutSetBranchId the layout set branch ID
1508            * @param plid the plid
1509            * @param status the status
1510            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1511            * @return the last matching layout revision
1512            * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found
1513            */
1514            public LayoutRevision findByL_P_S_Last(long layoutSetBranchId, long plid,
1515                    int status,
1516                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1517                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1518    
1519            /**
1520            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1521            *
1522            * @param layoutSetBranchId the layout set branch ID
1523            * @param plid the plid
1524            * @param status the status
1525            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1526            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1527            */
1528            public LayoutRevision fetchByL_P_S_Last(long layoutSetBranchId, long plid,
1529                    int status,
1530                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1531    
1532            /**
1533            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1534            *
1535            * @param layoutRevisionId the primary key of the current layout revision
1536            * @param layoutSetBranchId the layout set branch ID
1537            * @param plid the plid
1538            * @param status the status
1539            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1540            * @return the previous, current, and next layout revision
1541            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1542            */
1543            public LayoutRevision[] findByL_P_S_PrevAndNext(long layoutRevisionId,
1544                    long layoutSetBranchId, long plid, int status,
1545                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator)
1546                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1547    
1548            /**
1549            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63; from the database.
1550            *
1551            * @param layoutSetBranchId the layout set branch ID
1552            * @param plid the plid
1553            * @param status the status
1554            */
1555            public void removeByL_P_S(long layoutSetBranchId, long plid, int status);
1556    
1557            /**
1558            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1559            *
1560            * @param layoutSetBranchId the layout set branch ID
1561            * @param plid the plid
1562            * @param status the status
1563            * @return the number of matching layout revisions
1564            */
1565            public int countByL_P_S(long layoutSetBranchId, long plid, int status);
1566    
1567            /**
1568            * Caches the layout revision in the entity cache if it is enabled.
1569            *
1570            * @param layoutRevision the layout revision
1571            */
1572            public void cacheResult(LayoutRevision layoutRevision);
1573    
1574            /**
1575            * Caches the layout revisions in the entity cache if it is enabled.
1576            *
1577            * @param layoutRevisions the layout revisions
1578            */
1579            public void cacheResult(java.util.List<LayoutRevision> layoutRevisions);
1580    
1581            /**
1582            * Creates a new layout revision with the primary key. Does not add the layout revision to the database.
1583            *
1584            * @param layoutRevisionId the primary key for the new layout revision
1585            * @return the new layout revision
1586            */
1587            public LayoutRevision create(long layoutRevisionId);
1588    
1589            /**
1590            * Removes the layout revision with the primary key from the database. Also notifies the appropriate model listeners.
1591            *
1592            * @param layoutRevisionId the primary key of the layout revision
1593            * @return the layout revision that was removed
1594            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1595            */
1596            public LayoutRevision remove(long layoutRevisionId)
1597                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1598    
1599            public LayoutRevision updateImpl(LayoutRevision layoutRevision);
1600    
1601            /**
1602            * Returns the layout revision with the primary key or throws a {@link NoSuchLayoutRevisionException} if it could not be found.
1603            *
1604            * @param layoutRevisionId the primary key of the layout revision
1605            * @return the layout revision
1606            * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1607            */
1608            public LayoutRevision findByPrimaryKey(long layoutRevisionId)
1609                    throws com.liferay.portal.exception.NoSuchLayoutRevisionException;
1610    
1611            /**
1612            * Returns the layout revision with the primary key or returns <code>null</code> if it could not be found.
1613            *
1614            * @param layoutRevisionId the primary key of the layout revision
1615            * @return the layout revision, or <code>null</code> if a layout revision with the primary key could not be found
1616            */
1617            public LayoutRevision fetchByPrimaryKey(long layoutRevisionId);
1618    
1619            @Override
1620            public java.util.Map<java.io.Serializable, LayoutRevision> fetchByPrimaryKeys(
1621                    java.util.Set<java.io.Serializable> primaryKeys);
1622    
1623            /**
1624            * Returns all the layout revisions.
1625            *
1626            * @return the layout revisions
1627            */
1628            public java.util.List<LayoutRevision> findAll();
1629    
1630            /**
1631            * Returns a range of all the layout revisions.
1632            *
1633            * <p>
1634            * 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.
1635            * </p>
1636            *
1637            * @param start the lower bound of the range of layout revisions
1638            * @param end the upper bound of the range of layout revisions (not inclusive)
1639            * @return the range of layout revisions
1640            */
1641            public java.util.List<LayoutRevision> findAll(int start, int end);
1642    
1643            /**
1644            * Returns an ordered range of all the layout revisions.
1645            *
1646            * <p>
1647            * 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.
1648            * </p>
1649            *
1650            * @param start the lower bound of the range of layout revisions
1651            * @param end the upper bound of the range of layout revisions (not inclusive)
1652            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1653            * @return the ordered range of layout revisions
1654            */
1655            public java.util.List<LayoutRevision> findAll(int start, int end,
1656                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator);
1657    
1658            /**
1659            * Returns an ordered range of all the layout revisions.
1660            *
1661            * <p>
1662            * 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.
1663            * </p>
1664            *
1665            * @param start the lower bound of the range of layout revisions
1666            * @param end the upper bound of the range of layout revisions (not inclusive)
1667            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1668            * @param retrieveFromCache whether to retrieve from the finder cache
1669            * @return the ordered range of layout revisions
1670            */
1671            public java.util.List<LayoutRevision> findAll(int start, int end,
1672                    com.liferay.portal.kernel.util.OrderByComparator<LayoutRevision> orderByComparator,
1673                    boolean retrieveFromCache);
1674    
1675            /**
1676            * Removes all the layout revisions from the database.
1677            */
1678            public void removeAll();
1679    
1680            /**
1681            * Returns the number of layout revisions.
1682            *
1683            * @return the number of layout revisions
1684            */
1685            public int countAll();
1686    }