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