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