001    /**
002     * Copyright (c) 2000-2013 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.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.util.OrderByComparator;
023    import com.liferay.portal.kernel.util.ReferenceRegistry;
024    import com.liferay.portal.model.LayoutRevision;
025    import com.liferay.portal.service.ServiceContext;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the layout revision service. This utility wraps {@link LayoutRevisionPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see LayoutRevisionPersistence
038     * @see LayoutRevisionPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class LayoutRevisionUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(LayoutRevision layoutRevision) {
060                    getPersistence().clearCache(layoutRevision);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
067                    throws SystemException {
068                    return getPersistence().countWithDynamicQuery(dynamicQuery);
069            }
070    
071            /**
072             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
073             */
074            public static List<LayoutRevision> findWithDynamicQuery(
075                    DynamicQuery dynamicQuery) throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
081             */
082            public static List<LayoutRevision> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end)
084                    throws SystemException {
085                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
086            }
087    
088            /**
089             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
090             */
091            public static List<LayoutRevision> findWithDynamicQuery(
092                    DynamicQuery dynamicQuery, int start, int end,
093                    OrderByComparator orderByComparator) throws SystemException {
094                    return getPersistence()
095                                       .findWithDynamicQuery(dynamicQuery, start, end,
096                            orderByComparator);
097            }
098    
099            /**
100             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
101             */
102            public static LayoutRevision update(LayoutRevision layoutRevision)
103                    throws SystemException {
104                    return getPersistence().update(layoutRevision);
105            }
106    
107            /**
108             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
109             */
110            public static LayoutRevision update(LayoutRevision layoutRevision,
111                    ServiceContext serviceContext) throws SystemException {
112                    return getPersistence().update(layoutRevision, serviceContext);
113            }
114    
115            /**
116            * Returns all the layout revisions where layoutSetBranchId = &#63;.
117            *
118            * @param layoutSetBranchId the layout set branch ID
119            * @return the matching layout revisions
120            * @throws SystemException if a system exception occurred
121            */
122            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByLayoutSetBranchId(
123                    long layoutSetBranchId)
124                    throws com.liferay.portal.kernel.exception.SystemException {
125                    return getPersistence().findByLayoutSetBranchId(layoutSetBranchId);
126            }
127    
128            /**
129            * Returns a range of all the layout revisions where layoutSetBranchId = &#63;.
130            *
131            * <p>
132            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
133            * </p>
134            *
135            * @param layoutSetBranchId the layout set branch ID
136            * @param start the lower bound of the range of layout revisions
137            * @param end the upper bound of the range of layout revisions (not inclusive)
138            * @return the range of matching layout revisions
139            * @throws SystemException if a system exception occurred
140            */
141            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByLayoutSetBranchId(
142                    long layoutSetBranchId, int start, int end)
143                    throws com.liferay.portal.kernel.exception.SystemException {
144                    return getPersistence()
145                                       .findByLayoutSetBranchId(layoutSetBranchId, start, end);
146            }
147    
148            /**
149            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63;.
150            *
151            * <p>
152            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
153            * </p>
154            *
155            * @param layoutSetBranchId the layout set branch ID
156            * @param start the lower bound of the range of layout revisions
157            * @param end the upper bound of the range of layout revisions (not inclusive)
158            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
159            * @return the ordered range of matching layout revisions
160            * @throws SystemException if a system exception occurred
161            */
162            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByLayoutSetBranchId(
163                    long layoutSetBranchId, int start, int end,
164                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
165                    throws com.liferay.portal.kernel.exception.SystemException {
166                    return getPersistence()
167                                       .findByLayoutSetBranchId(layoutSetBranchId, start, end,
168                            orderByComparator);
169            }
170    
171            /**
172            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63;.
173            *
174            * @param layoutSetBranchId the layout set branch ID
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching layout revision
177            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
178            * @throws SystemException if a system exception occurred
179            */
180            public static com.liferay.portal.model.LayoutRevision findByLayoutSetBranchId_First(
181                    long layoutSetBranchId,
182                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
183                    throws com.liferay.portal.NoSuchLayoutRevisionException,
184                            com.liferay.portal.kernel.exception.SystemException {
185                    return getPersistence()
186                                       .findByLayoutSetBranchId_First(layoutSetBranchId,
187                            orderByComparator);
188            }
189    
190            /**
191            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63;.
192            *
193            * @param layoutSetBranchId the layout set branch ID
194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
195            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
196            * @throws SystemException if a system exception occurred
197            */
198            public static com.liferay.portal.model.LayoutRevision fetchByLayoutSetBranchId_First(
199                    long layoutSetBranchId,
200                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
201                    throws com.liferay.portal.kernel.exception.SystemException {
202                    return getPersistence()
203                                       .fetchByLayoutSetBranchId_First(layoutSetBranchId,
204                            orderByComparator);
205            }
206    
207            /**
208            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63;.
209            *
210            * @param layoutSetBranchId the layout set branch ID
211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
212            * @return the last matching layout revision
213            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
214            * @throws SystemException if a system exception occurred
215            */
216            public static com.liferay.portal.model.LayoutRevision findByLayoutSetBranchId_Last(
217                    long layoutSetBranchId,
218                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
219                    throws com.liferay.portal.NoSuchLayoutRevisionException,
220                            com.liferay.portal.kernel.exception.SystemException {
221                    return getPersistence()
222                                       .findByLayoutSetBranchId_Last(layoutSetBranchId,
223                            orderByComparator);
224            }
225    
226            /**
227            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63;.
228            *
229            * @param layoutSetBranchId the layout set branch ID
230            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
231            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
232            * @throws SystemException if a system exception occurred
233            */
234            public static com.liferay.portal.model.LayoutRevision fetchByLayoutSetBranchId_Last(
235                    long layoutSetBranchId,
236                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
237                    throws com.liferay.portal.kernel.exception.SystemException {
238                    return getPersistence()
239                                       .fetchByLayoutSetBranchId_Last(layoutSetBranchId,
240                            orderByComparator);
241            }
242    
243            /**
244            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63;.
245            *
246            * @param layoutRevisionId the primary key of the current layout revision
247            * @param layoutSetBranchId the layout set branch ID
248            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
249            * @return the previous, current, and next layout revision
250            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
251            * @throws SystemException if a system exception occurred
252            */
253            public static com.liferay.portal.model.LayoutRevision[] findByLayoutSetBranchId_PrevAndNext(
254                    long layoutRevisionId, long layoutSetBranchId,
255                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
256                    throws com.liferay.portal.NoSuchLayoutRevisionException,
257                            com.liferay.portal.kernel.exception.SystemException {
258                    return getPersistence()
259                                       .findByLayoutSetBranchId_PrevAndNext(layoutRevisionId,
260                            layoutSetBranchId, orderByComparator);
261            }
262    
263            /**
264            * Removes all the layout revisions where layoutSetBranchId = &#63; from the database.
265            *
266            * @param layoutSetBranchId the layout set branch ID
267            * @throws SystemException if a system exception occurred
268            */
269            public static void removeByLayoutSetBranchId(long layoutSetBranchId)
270                    throws com.liferay.portal.kernel.exception.SystemException {
271                    getPersistence().removeByLayoutSetBranchId(layoutSetBranchId);
272            }
273    
274            /**
275            * Returns the number of layout revisions where layoutSetBranchId = &#63;.
276            *
277            * @param layoutSetBranchId the layout set branch ID
278            * @return the number of matching layout revisions
279            * @throws SystemException if a system exception occurred
280            */
281            public static int countByLayoutSetBranchId(long layoutSetBranchId)
282                    throws com.liferay.portal.kernel.exception.SystemException {
283                    return getPersistence().countByLayoutSetBranchId(layoutSetBranchId);
284            }
285    
286            /**
287            * Returns all the layout revisions where plid = &#63;.
288            *
289            * @param plid the plid
290            * @return the matching layout revisions
291            * @throws SystemException if a system exception occurred
292            */
293            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByPlid(
294                    long plid) throws com.liferay.portal.kernel.exception.SystemException {
295                    return getPersistence().findByPlid(plid);
296            }
297    
298            /**
299            * Returns a range of all the layout revisions where plid = &#63;.
300            *
301            * <p>
302            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
303            * </p>
304            *
305            * @param plid the plid
306            * @param start the lower bound of the range of layout revisions
307            * @param end the upper bound of the range of layout revisions (not inclusive)
308            * @return the range of matching layout revisions
309            * @throws SystemException if a system exception occurred
310            */
311            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByPlid(
312                    long plid, int start, int end)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().findByPlid(plid, start, end);
315            }
316    
317            /**
318            * Returns an ordered range of all the layout revisions where plid = &#63;.
319            *
320            * <p>
321            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
322            * </p>
323            *
324            * @param plid the plid
325            * @param start the lower bound of the range of layout revisions
326            * @param end the upper bound of the range of layout revisions (not inclusive)
327            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
328            * @return the ordered range of matching layout revisions
329            * @throws SystemException if a system exception occurred
330            */
331            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByPlid(
332                    long plid, int start, int end,
333                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
334                    throws com.liferay.portal.kernel.exception.SystemException {
335                    return getPersistence().findByPlid(plid, start, end, orderByComparator);
336            }
337    
338            /**
339            * Returns the first layout revision in the ordered set where plid = &#63;.
340            *
341            * @param plid the plid
342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
343            * @return the first matching layout revision
344            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
345            * @throws SystemException if a system exception occurred
346            */
347            public static com.liferay.portal.model.LayoutRevision findByPlid_First(
348                    long plid,
349                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
350                    throws com.liferay.portal.NoSuchLayoutRevisionException,
351                            com.liferay.portal.kernel.exception.SystemException {
352                    return getPersistence().findByPlid_First(plid, orderByComparator);
353            }
354    
355            /**
356            * Returns the first layout revision in the ordered set where plid = &#63;.
357            *
358            * @param plid the plid
359            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
360            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
361            * @throws SystemException if a system exception occurred
362            */
363            public static com.liferay.portal.model.LayoutRevision fetchByPlid_First(
364                    long plid,
365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
366                    throws com.liferay.portal.kernel.exception.SystemException {
367                    return getPersistence().fetchByPlid_First(plid, orderByComparator);
368            }
369    
370            /**
371            * Returns the last layout revision in the ordered set where plid = &#63;.
372            *
373            * @param plid the plid
374            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
375            * @return the last matching layout revision
376            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
377            * @throws SystemException if a system exception occurred
378            */
379            public static com.liferay.portal.model.LayoutRevision findByPlid_Last(
380                    long plid,
381                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
382                    throws com.liferay.portal.NoSuchLayoutRevisionException,
383                            com.liferay.portal.kernel.exception.SystemException {
384                    return getPersistence().findByPlid_Last(plid, orderByComparator);
385            }
386    
387            /**
388            * Returns the last layout revision in the ordered set where plid = &#63;.
389            *
390            * @param plid the plid
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
393            * @throws SystemException if a system exception occurred
394            */
395            public static com.liferay.portal.model.LayoutRevision fetchByPlid_Last(
396                    long plid,
397                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
398                    throws com.liferay.portal.kernel.exception.SystemException {
399                    return getPersistence().fetchByPlid_Last(plid, orderByComparator);
400            }
401    
402            /**
403            * Returns the layout revisions before and after the current layout revision in the ordered set where plid = &#63;.
404            *
405            * @param layoutRevisionId the primary key of the current layout revision
406            * @param plid the plid
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the previous, current, and next layout revision
409            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portal.model.LayoutRevision[] findByPlid_PrevAndNext(
413                    long layoutRevisionId, long plid,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.NoSuchLayoutRevisionException,
416                            com.liferay.portal.kernel.exception.SystemException {
417                    return getPersistence()
418                                       .findByPlid_PrevAndNext(layoutRevisionId, plid,
419                            orderByComparator);
420            }
421    
422            /**
423            * Removes all the layout revisions where plid = &#63; from the database.
424            *
425            * @param plid the plid
426            * @throws SystemException if a system exception occurred
427            */
428            public static void removeByPlid(long plid)
429                    throws com.liferay.portal.kernel.exception.SystemException {
430                    getPersistence().removeByPlid(plid);
431            }
432    
433            /**
434            * Returns the number of layout revisions where plid = &#63;.
435            *
436            * @param plid the plid
437            * @return the number of matching layout revisions
438            * @throws SystemException if a system exception occurred
439            */
440            public static int countByPlid(long plid)
441                    throws com.liferay.portal.kernel.exception.SystemException {
442                    return getPersistence().countByPlid(plid);
443            }
444    
445            /**
446            * Returns all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
447            *
448            * @param layoutSetBranchId the layout set branch ID
449            * @param head the head
450            * @return the matching layout revisions
451            * @throws SystemException if a system exception occurred
452            */
453            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_H(
454                    long layoutSetBranchId, boolean head)
455                    throws com.liferay.portal.kernel.exception.SystemException {
456                    return getPersistence().findByL_H(layoutSetBranchId, head);
457            }
458    
459            /**
460            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
461            *
462            * <p>
463            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
464            * </p>
465            *
466            * @param layoutSetBranchId the layout set branch ID
467            * @param head the head
468            * @param start the lower bound of the range of layout revisions
469            * @param end the upper bound of the range of layout revisions (not inclusive)
470            * @return the range of matching layout revisions
471            * @throws SystemException if a system exception occurred
472            */
473            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_H(
474                    long layoutSetBranchId, boolean head, int start, int end)
475                    throws com.liferay.portal.kernel.exception.SystemException {
476                    return getPersistence().findByL_H(layoutSetBranchId, head, start, end);
477            }
478    
479            /**
480            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and head = &#63;.
481            *
482            * <p>
483            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
484            * </p>
485            *
486            * @param layoutSetBranchId the layout set branch ID
487            * @param head the head
488            * @param start the lower bound of the range of layout revisions
489            * @param end the upper bound of the range of layout revisions (not inclusive)
490            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
491            * @return the ordered range of matching layout revisions
492            * @throws SystemException if a system exception occurred
493            */
494            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_H(
495                    long layoutSetBranchId, boolean head, int start, int end,
496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
497                    throws com.liferay.portal.kernel.exception.SystemException {
498                    return getPersistence()
499                                       .findByL_H(layoutSetBranchId, head, start, end,
500                            orderByComparator);
501            }
502    
503            /**
504            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
505            *
506            * @param layoutSetBranchId the layout set branch ID
507            * @param head the head
508            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
509            * @return the first matching layout revision
510            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
511            * @throws SystemException if a system exception occurred
512            */
513            public static com.liferay.portal.model.LayoutRevision findByL_H_First(
514                    long layoutSetBranchId, boolean head,
515                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
516                    throws com.liferay.portal.NoSuchLayoutRevisionException,
517                            com.liferay.portal.kernel.exception.SystemException {
518                    return getPersistence()
519                                       .findByL_H_First(layoutSetBranchId, head, orderByComparator);
520            }
521    
522            /**
523            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
524            *
525            * @param layoutSetBranchId the layout set branch ID
526            * @param head the head
527            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
528            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
529            * @throws SystemException if a system exception occurred
530            */
531            public static com.liferay.portal.model.LayoutRevision fetchByL_H_First(
532                    long layoutSetBranchId, boolean head,
533                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
534                    throws com.liferay.portal.kernel.exception.SystemException {
535                    return getPersistence()
536                                       .fetchByL_H_First(layoutSetBranchId, head, orderByComparator);
537            }
538    
539            /**
540            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
541            *
542            * @param layoutSetBranchId the layout set branch ID
543            * @param head the head
544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
545            * @return the last matching layout revision
546            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
547            * @throws SystemException if a system exception occurred
548            */
549            public static com.liferay.portal.model.LayoutRevision findByL_H_Last(
550                    long layoutSetBranchId, boolean head,
551                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
552                    throws com.liferay.portal.NoSuchLayoutRevisionException,
553                            com.liferay.portal.kernel.exception.SystemException {
554                    return getPersistence()
555                                       .findByL_H_Last(layoutSetBranchId, head, orderByComparator);
556            }
557    
558            /**
559            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
560            *
561            * @param layoutSetBranchId the layout set branch ID
562            * @param head the head
563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
564            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
565            * @throws SystemException if a system exception occurred
566            */
567            public static com.liferay.portal.model.LayoutRevision fetchByL_H_Last(
568                    long layoutSetBranchId, boolean head,
569                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
570                    throws com.liferay.portal.kernel.exception.SystemException {
571                    return getPersistence()
572                                       .fetchByL_H_Last(layoutSetBranchId, head, orderByComparator);
573            }
574    
575            /**
576            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and head = &#63;.
577            *
578            * @param layoutRevisionId the primary key of the current layout revision
579            * @param layoutSetBranchId the layout set branch ID
580            * @param head the head
581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
582            * @return the previous, current, and next layout revision
583            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
584            * @throws SystemException if a system exception occurred
585            */
586            public static com.liferay.portal.model.LayoutRevision[] findByL_H_PrevAndNext(
587                    long layoutRevisionId, long layoutSetBranchId, boolean head,
588                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
589                    throws com.liferay.portal.NoSuchLayoutRevisionException,
590                            com.liferay.portal.kernel.exception.SystemException {
591                    return getPersistence()
592                                       .findByL_H_PrevAndNext(layoutRevisionId, layoutSetBranchId,
593                            head, orderByComparator);
594            }
595    
596            /**
597            * Removes all the layout revisions where layoutSetBranchId = &#63; and head = &#63; from the database.
598            *
599            * @param layoutSetBranchId the layout set branch ID
600            * @param head the head
601            * @throws SystemException if a system exception occurred
602            */
603            public static void removeByL_H(long layoutSetBranchId, boolean head)
604                    throws com.liferay.portal.kernel.exception.SystemException {
605                    getPersistence().removeByL_H(layoutSetBranchId, head);
606            }
607    
608            /**
609            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63;.
610            *
611            * @param layoutSetBranchId the layout set branch ID
612            * @param head the head
613            * @return the number of matching layout revisions
614            * @throws SystemException if a system exception occurred
615            */
616            public static int countByL_H(long layoutSetBranchId, boolean head)
617                    throws com.liferay.portal.kernel.exception.SystemException {
618                    return getPersistence().countByL_H(layoutSetBranchId, head);
619            }
620    
621            /**
622            * Returns all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
623            *
624            * @param layoutSetBranchId the layout set branch ID
625            * @param plid the plid
626            * @return the matching layout revisions
627            * @throws SystemException if a system exception occurred
628            */
629            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P(
630                    long layoutSetBranchId, long plid)
631                    throws com.liferay.portal.kernel.exception.SystemException {
632                    return getPersistence().findByL_P(layoutSetBranchId, plid);
633            }
634    
635            /**
636            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
637            *
638            * <p>
639            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
640            * </p>
641            *
642            * @param layoutSetBranchId the layout set branch ID
643            * @param plid the plid
644            * @param start the lower bound of the range of layout revisions
645            * @param end the upper bound of the range of layout revisions (not inclusive)
646            * @return the range of matching layout revisions
647            * @throws SystemException if a system exception occurred
648            */
649            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P(
650                    long layoutSetBranchId, long plid, int start, int end)
651                    throws com.liferay.portal.kernel.exception.SystemException {
652                    return getPersistence().findByL_P(layoutSetBranchId, plid, start, end);
653            }
654    
655            /**
656            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
657            *
658            * <p>
659            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
660            * </p>
661            *
662            * @param layoutSetBranchId the layout set branch ID
663            * @param plid the plid
664            * @param start the lower bound of the range of layout revisions
665            * @param end the upper bound of the range of layout revisions (not inclusive)
666            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
667            * @return the ordered range of matching layout revisions
668            * @throws SystemException if a system exception occurred
669            */
670            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P(
671                    long layoutSetBranchId, long plid, int start, int end,
672                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
673                    throws com.liferay.portal.kernel.exception.SystemException {
674                    return getPersistence()
675                                       .findByL_P(layoutSetBranchId, plid, start, end,
676                            orderByComparator);
677            }
678    
679            /**
680            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
681            *
682            * @param layoutSetBranchId the layout set branch ID
683            * @param plid the plid
684            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
685            * @return the first matching layout revision
686            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
687            * @throws SystemException if a system exception occurred
688            */
689            public static com.liferay.portal.model.LayoutRevision findByL_P_First(
690                    long layoutSetBranchId, long plid,
691                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
692                    throws com.liferay.portal.NoSuchLayoutRevisionException,
693                            com.liferay.portal.kernel.exception.SystemException {
694                    return getPersistence()
695                                       .findByL_P_First(layoutSetBranchId, plid, orderByComparator);
696            }
697    
698            /**
699            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
700            *
701            * @param layoutSetBranchId the layout set branch ID
702            * @param plid the plid
703            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
704            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
705            * @throws SystemException if a system exception occurred
706            */
707            public static com.liferay.portal.model.LayoutRevision fetchByL_P_First(
708                    long layoutSetBranchId, long plid,
709                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
710                    throws com.liferay.portal.kernel.exception.SystemException {
711                    return getPersistence()
712                                       .fetchByL_P_First(layoutSetBranchId, plid, orderByComparator);
713            }
714    
715            /**
716            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
717            *
718            * @param layoutSetBranchId the layout set branch ID
719            * @param plid the plid
720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
721            * @return the last matching layout revision
722            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
723            * @throws SystemException if a system exception occurred
724            */
725            public static com.liferay.portal.model.LayoutRevision findByL_P_Last(
726                    long layoutSetBranchId, long plid,
727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
728                    throws com.liferay.portal.NoSuchLayoutRevisionException,
729                            com.liferay.portal.kernel.exception.SystemException {
730                    return getPersistence()
731                                       .findByL_P_Last(layoutSetBranchId, plid, orderByComparator);
732            }
733    
734            /**
735            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
736            *
737            * @param layoutSetBranchId the layout set branch ID
738            * @param plid the plid
739            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
740            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
741            * @throws SystemException if a system exception occurred
742            */
743            public static com.liferay.portal.model.LayoutRevision fetchByL_P_Last(
744                    long layoutSetBranchId, long plid,
745                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
746                    throws com.liferay.portal.kernel.exception.SystemException {
747                    return getPersistence()
748                                       .fetchByL_P_Last(layoutSetBranchId, plid, orderByComparator);
749            }
750    
751            /**
752            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63;.
753            *
754            * @param layoutRevisionId the primary key of the current layout revision
755            * @param layoutSetBranchId the layout set branch ID
756            * @param plid the plid
757            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
758            * @return the previous, current, and next layout revision
759            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
760            * @throws SystemException if a system exception occurred
761            */
762            public static com.liferay.portal.model.LayoutRevision[] findByL_P_PrevAndNext(
763                    long layoutRevisionId, long layoutSetBranchId, long plid,
764                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
765                    throws com.liferay.portal.NoSuchLayoutRevisionException,
766                            com.liferay.portal.kernel.exception.SystemException {
767                    return getPersistence()
768                                       .findByL_P_PrevAndNext(layoutRevisionId, layoutSetBranchId,
769                            plid, orderByComparator);
770            }
771    
772            /**
773            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; from the database.
774            *
775            * @param layoutSetBranchId the layout set branch ID
776            * @param plid the plid
777            * @throws SystemException if a system exception occurred
778            */
779            public static void removeByL_P(long layoutSetBranchId, long plid)
780                    throws com.liferay.portal.kernel.exception.SystemException {
781                    getPersistence().removeByL_P(layoutSetBranchId, plid);
782            }
783    
784            /**
785            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
786            *
787            * @param layoutSetBranchId the layout set branch ID
788            * @param plid the plid
789            * @return the number of matching layout revisions
790            * @throws SystemException if a system exception occurred
791            */
792            public static int countByL_P(long layoutSetBranchId, long plid)
793                    throws com.liferay.portal.kernel.exception.SystemException {
794                    return getPersistence().countByL_P(layoutSetBranchId, plid);
795            }
796    
797            /**
798            * Returns all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
799            *
800            * @param layoutSetBranchId the layout set branch ID
801            * @param status the status
802            * @return the matching layout revisions
803            * @throws SystemException if a system exception occurred
804            */
805            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_S(
806                    long layoutSetBranchId, int status)
807                    throws com.liferay.portal.kernel.exception.SystemException {
808                    return getPersistence().findByL_S(layoutSetBranchId, status);
809            }
810    
811            /**
812            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
813            *
814            * <p>
815            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
816            * </p>
817            *
818            * @param layoutSetBranchId the layout set branch ID
819            * @param status the status
820            * @param start the lower bound of the range of layout revisions
821            * @param end the upper bound of the range of layout revisions (not inclusive)
822            * @return the range of matching layout revisions
823            * @throws SystemException if a system exception occurred
824            */
825            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_S(
826                    long layoutSetBranchId, int status, int start, int end)
827                    throws com.liferay.portal.kernel.exception.SystemException {
828                    return getPersistence().findByL_S(layoutSetBranchId, status, start, end);
829            }
830    
831            /**
832            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and status = &#63;.
833            *
834            * <p>
835            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
836            * </p>
837            *
838            * @param layoutSetBranchId the layout set branch ID
839            * @param status the status
840            * @param start the lower bound of the range of layout revisions
841            * @param end the upper bound of the range of layout revisions (not inclusive)
842            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
843            * @return the ordered range of matching layout revisions
844            * @throws SystemException if a system exception occurred
845            */
846            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_S(
847                    long layoutSetBranchId, int status, int start, int end,
848                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
849                    throws com.liferay.portal.kernel.exception.SystemException {
850                    return getPersistence()
851                                       .findByL_S(layoutSetBranchId, status, start, end,
852                            orderByComparator);
853            }
854    
855            /**
856            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
857            *
858            * @param layoutSetBranchId the layout set branch ID
859            * @param status the status
860            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
861            * @return the first matching layout revision
862            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
863            * @throws SystemException if a system exception occurred
864            */
865            public static com.liferay.portal.model.LayoutRevision findByL_S_First(
866                    long layoutSetBranchId, int status,
867                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
868                    throws com.liferay.portal.NoSuchLayoutRevisionException,
869                            com.liferay.portal.kernel.exception.SystemException {
870                    return getPersistence()
871                                       .findByL_S_First(layoutSetBranchId, status, orderByComparator);
872            }
873    
874            /**
875            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
876            *
877            * @param layoutSetBranchId the layout set branch ID
878            * @param status the status
879            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
880            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
881            * @throws SystemException if a system exception occurred
882            */
883            public static com.liferay.portal.model.LayoutRevision fetchByL_S_First(
884                    long layoutSetBranchId, int status,
885                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return getPersistence()
888                                       .fetchByL_S_First(layoutSetBranchId, status,
889                            orderByComparator);
890            }
891    
892            /**
893            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
894            *
895            * @param layoutSetBranchId the layout set branch ID
896            * @param status the status
897            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
898            * @return the last matching layout revision
899            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
900            * @throws SystemException if a system exception occurred
901            */
902            public static com.liferay.portal.model.LayoutRevision findByL_S_Last(
903                    long layoutSetBranchId, int status,
904                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
905                    throws com.liferay.portal.NoSuchLayoutRevisionException,
906                            com.liferay.portal.kernel.exception.SystemException {
907                    return getPersistence()
908                                       .findByL_S_Last(layoutSetBranchId, status, orderByComparator);
909            }
910    
911            /**
912            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
913            *
914            * @param layoutSetBranchId the layout set branch ID
915            * @param status the status
916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
917            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
918            * @throws SystemException if a system exception occurred
919            */
920            public static com.liferay.portal.model.LayoutRevision fetchByL_S_Last(
921                    long layoutSetBranchId, int status,
922                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
923                    throws com.liferay.portal.kernel.exception.SystemException {
924                    return getPersistence()
925                                       .fetchByL_S_Last(layoutSetBranchId, status, orderByComparator);
926            }
927    
928            /**
929            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and status = &#63;.
930            *
931            * @param layoutRevisionId the primary key of the current layout revision
932            * @param layoutSetBranchId the layout set branch ID
933            * @param status the status
934            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
935            * @return the previous, current, and next layout revision
936            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
937            * @throws SystemException if a system exception occurred
938            */
939            public static com.liferay.portal.model.LayoutRevision[] findByL_S_PrevAndNext(
940                    long layoutRevisionId, long layoutSetBranchId, int status,
941                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
942                    throws com.liferay.portal.NoSuchLayoutRevisionException,
943                            com.liferay.portal.kernel.exception.SystemException {
944                    return getPersistence()
945                                       .findByL_S_PrevAndNext(layoutRevisionId, layoutSetBranchId,
946                            status, orderByComparator);
947            }
948    
949            /**
950            * Removes all the layout revisions where layoutSetBranchId = &#63; and status = &#63; from the database.
951            *
952            * @param layoutSetBranchId the layout set branch ID
953            * @param status the status
954            * @throws SystemException if a system exception occurred
955            */
956            public static void removeByL_S(long layoutSetBranchId, int status)
957                    throws com.liferay.portal.kernel.exception.SystemException {
958                    getPersistence().removeByL_S(layoutSetBranchId, status);
959            }
960    
961            /**
962            * Returns the number of layout revisions where layoutSetBranchId = &#63; and status = &#63;.
963            *
964            * @param layoutSetBranchId the layout set branch ID
965            * @param status the status
966            * @return the number of matching layout revisions
967            * @throws SystemException if a system exception occurred
968            */
969            public static int countByL_S(long layoutSetBranchId, int status)
970                    throws com.liferay.portal.kernel.exception.SystemException {
971                    return getPersistence().countByL_S(layoutSetBranchId, status);
972            }
973    
974            /**
975            * Returns all the layout revisions where head = &#63; and plid = &#63;.
976            *
977            * @param head the head
978            * @param plid the plid
979            * @return the matching layout revisions
980            * @throws SystemException if a system exception occurred
981            */
982            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByH_P(
983                    boolean head, long plid)
984                    throws com.liferay.portal.kernel.exception.SystemException {
985                    return getPersistence().findByH_P(head, plid);
986            }
987    
988            /**
989            * Returns a range of all the layout revisions where head = &#63; and plid = &#63;.
990            *
991            * <p>
992            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
993            * </p>
994            *
995            * @param head the head
996            * @param plid the plid
997            * @param start the lower bound of the range of layout revisions
998            * @param end the upper bound of the range of layout revisions (not inclusive)
999            * @return the range of matching layout revisions
1000            * @throws SystemException if a system exception occurred
1001            */
1002            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByH_P(
1003                    boolean head, long plid, int start, int end)
1004                    throws com.liferay.portal.kernel.exception.SystemException {
1005                    return getPersistence().findByH_P(head, plid, start, end);
1006            }
1007    
1008            /**
1009            * Returns an ordered range of all the layout revisions where head = &#63; and plid = &#63;.
1010            *
1011            * <p>
1012            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1013            * </p>
1014            *
1015            * @param head the head
1016            * @param plid the plid
1017            * @param start the lower bound of the range of layout revisions
1018            * @param end the upper bound of the range of layout revisions (not inclusive)
1019            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1020            * @return the ordered range of matching layout revisions
1021            * @throws SystemException if a system exception occurred
1022            */
1023            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByH_P(
1024                    boolean head, long plid, int start, int end,
1025                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1026                    throws com.liferay.portal.kernel.exception.SystemException {
1027                    return getPersistence()
1028                                       .findByH_P(head, plid, start, end, orderByComparator);
1029            }
1030    
1031            /**
1032            * Returns the first layout revision in the ordered set where head = &#63; and plid = &#63;.
1033            *
1034            * @param head the head
1035            * @param plid the plid
1036            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1037            * @return the first matching layout revision
1038            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1039            * @throws SystemException if a system exception occurred
1040            */
1041            public static com.liferay.portal.model.LayoutRevision findByH_P_First(
1042                    boolean head, long plid,
1043                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1044                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1045                            com.liferay.portal.kernel.exception.SystemException {
1046                    return getPersistence().findByH_P_First(head, plid, orderByComparator);
1047            }
1048    
1049            /**
1050            * Returns the first layout revision in the ordered set where head = &#63; and plid = &#63;.
1051            *
1052            * @param head the head
1053            * @param plid the plid
1054            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1055            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1056            * @throws SystemException if a system exception occurred
1057            */
1058            public static com.liferay.portal.model.LayoutRevision fetchByH_P_First(
1059                    boolean head, long plid,
1060                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1061                    throws com.liferay.portal.kernel.exception.SystemException {
1062                    return getPersistence().fetchByH_P_First(head, plid, orderByComparator);
1063            }
1064    
1065            /**
1066            * Returns the last layout revision in the ordered set where head = &#63; and plid = &#63;.
1067            *
1068            * @param head the head
1069            * @param plid the plid
1070            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1071            * @return the last matching layout revision
1072            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1073            * @throws SystemException if a system exception occurred
1074            */
1075            public static com.liferay.portal.model.LayoutRevision findByH_P_Last(
1076                    boolean head, long plid,
1077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1078                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1079                            com.liferay.portal.kernel.exception.SystemException {
1080                    return getPersistence().findByH_P_Last(head, plid, orderByComparator);
1081            }
1082    
1083            /**
1084            * Returns the last layout revision in the ordered set where head = &#63; and plid = &#63;.
1085            *
1086            * @param head the head
1087            * @param plid the plid
1088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1089            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1090            * @throws SystemException if a system exception occurred
1091            */
1092            public static com.liferay.portal.model.LayoutRevision fetchByH_P_Last(
1093                    boolean head, long plid,
1094                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1095                    throws com.liferay.portal.kernel.exception.SystemException {
1096                    return getPersistence().fetchByH_P_Last(head, plid, orderByComparator);
1097            }
1098    
1099            /**
1100            * Returns the layout revisions before and after the current layout revision in the ordered set where head = &#63; and plid = &#63;.
1101            *
1102            * @param layoutRevisionId the primary key of the current layout revision
1103            * @param head the head
1104            * @param plid the plid
1105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1106            * @return the previous, current, and next layout revision
1107            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1108            * @throws SystemException if a system exception occurred
1109            */
1110            public static com.liferay.portal.model.LayoutRevision[] findByH_P_PrevAndNext(
1111                    long layoutRevisionId, boolean head, long plid,
1112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1113                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1114                            com.liferay.portal.kernel.exception.SystemException {
1115                    return getPersistence()
1116                                       .findByH_P_PrevAndNext(layoutRevisionId, head, plid,
1117                            orderByComparator);
1118            }
1119    
1120            /**
1121            * Removes all the layout revisions where head = &#63; and plid = &#63; from the database.
1122            *
1123            * @param head the head
1124            * @param plid the plid
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static void removeByH_P(boolean head, long plid)
1128                    throws com.liferay.portal.kernel.exception.SystemException {
1129                    getPersistence().removeByH_P(head, plid);
1130            }
1131    
1132            /**
1133            * Returns the number of layout revisions where head = &#63; and plid = &#63;.
1134            *
1135            * @param head the head
1136            * @param plid the plid
1137            * @return the number of matching layout revisions
1138            * @throws SystemException if a system exception occurred
1139            */
1140            public static int countByH_P(boolean head, long plid)
1141                    throws com.liferay.portal.kernel.exception.SystemException {
1142                    return getPersistence().countByH_P(head, plid);
1143            }
1144    
1145            /**
1146            * Returns all the layout revisions where plid = &#63; and status &ne; &#63;.
1147            *
1148            * @param plid the plid
1149            * @param status the status
1150            * @return the matching layout revisions
1151            * @throws SystemException if a system exception occurred
1152            */
1153            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByP_NotS(
1154                    long plid, int status)
1155                    throws com.liferay.portal.kernel.exception.SystemException {
1156                    return getPersistence().findByP_NotS(plid, status);
1157            }
1158    
1159            /**
1160            * Returns a range of all the layout revisions where plid = &#63; and status &ne; &#63;.
1161            *
1162            * <p>
1163            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1164            * </p>
1165            *
1166            * @param plid the plid
1167            * @param status the status
1168            * @param start the lower bound of the range of layout revisions
1169            * @param end the upper bound of the range of layout revisions (not inclusive)
1170            * @return the range of matching layout revisions
1171            * @throws SystemException if a system exception occurred
1172            */
1173            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByP_NotS(
1174                    long plid, int status, int start, int end)
1175                    throws com.liferay.portal.kernel.exception.SystemException {
1176                    return getPersistence().findByP_NotS(plid, status, start, end);
1177            }
1178    
1179            /**
1180            * Returns an ordered range of all the layout revisions where plid = &#63; and status &ne; &#63;.
1181            *
1182            * <p>
1183            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1184            * </p>
1185            *
1186            * @param plid the plid
1187            * @param status the status
1188            * @param start the lower bound of the range of layout revisions
1189            * @param end the upper bound of the range of layout revisions (not inclusive)
1190            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1191            * @return the ordered range of matching layout revisions
1192            * @throws SystemException if a system exception occurred
1193            */
1194            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByP_NotS(
1195                    long plid, int status, int start, int end,
1196                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1197                    throws com.liferay.portal.kernel.exception.SystemException {
1198                    return getPersistence()
1199                                       .findByP_NotS(plid, status, start, end, orderByComparator);
1200            }
1201    
1202            /**
1203            * Returns the first layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
1204            *
1205            * @param plid the plid
1206            * @param status the status
1207            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1208            * @return the first matching layout revision
1209            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1210            * @throws SystemException if a system exception occurred
1211            */
1212            public static com.liferay.portal.model.LayoutRevision findByP_NotS_First(
1213                    long plid, int status,
1214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1215                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1216                            com.liferay.portal.kernel.exception.SystemException {
1217                    return getPersistence()
1218                                       .findByP_NotS_First(plid, status, orderByComparator);
1219            }
1220    
1221            /**
1222            * Returns the first layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
1223            *
1224            * @param plid the plid
1225            * @param status the status
1226            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1227            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1228            * @throws SystemException if a system exception occurred
1229            */
1230            public static com.liferay.portal.model.LayoutRevision fetchByP_NotS_First(
1231                    long plid, int status,
1232                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1233                    throws com.liferay.portal.kernel.exception.SystemException {
1234                    return getPersistence()
1235                                       .fetchByP_NotS_First(plid, status, orderByComparator);
1236            }
1237    
1238            /**
1239            * Returns the last layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
1240            *
1241            * @param plid the plid
1242            * @param status the status
1243            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1244            * @return the last matching layout revision
1245            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1246            * @throws SystemException if a system exception occurred
1247            */
1248            public static com.liferay.portal.model.LayoutRevision findByP_NotS_Last(
1249                    long plid, int status,
1250                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1251                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1252                            com.liferay.portal.kernel.exception.SystemException {
1253                    return getPersistence()
1254                                       .findByP_NotS_Last(plid, status, orderByComparator);
1255            }
1256    
1257            /**
1258            * Returns the last layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
1259            *
1260            * @param plid the plid
1261            * @param status the status
1262            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1263            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1264            * @throws SystemException if a system exception occurred
1265            */
1266            public static com.liferay.portal.model.LayoutRevision fetchByP_NotS_Last(
1267                    long plid, int status,
1268                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1269                    throws com.liferay.portal.kernel.exception.SystemException {
1270                    return getPersistence()
1271                                       .fetchByP_NotS_Last(plid, status, orderByComparator);
1272            }
1273    
1274            /**
1275            * Returns the layout revisions before and after the current layout revision in the ordered set where plid = &#63; and status &ne; &#63;.
1276            *
1277            * @param layoutRevisionId the primary key of the current layout revision
1278            * @param plid the plid
1279            * @param status the status
1280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1281            * @return the previous, current, and next layout revision
1282            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1283            * @throws SystemException if a system exception occurred
1284            */
1285            public static com.liferay.portal.model.LayoutRevision[] findByP_NotS_PrevAndNext(
1286                    long layoutRevisionId, long plid, int status,
1287                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1288                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1289                            com.liferay.portal.kernel.exception.SystemException {
1290                    return getPersistence()
1291                                       .findByP_NotS_PrevAndNext(layoutRevisionId, plid, status,
1292                            orderByComparator);
1293            }
1294    
1295            /**
1296            * Removes all the layout revisions where plid = &#63; and status &ne; &#63; from the database.
1297            *
1298            * @param plid the plid
1299            * @param status the status
1300            * @throws SystemException if a system exception occurred
1301            */
1302            public static void removeByP_NotS(long plid, int status)
1303                    throws com.liferay.portal.kernel.exception.SystemException {
1304                    getPersistence().removeByP_NotS(plid, status);
1305            }
1306    
1307            /**
1308            * Returns the number of layout revisions where plid = &#63; and status &ne; &#63;.
1309            *
1310            * @param plid the plid
1311            * @param status the status
1312            * @return the number of matching layout revisions
1313            * @throws SystemException if a system exception occurred
1314            */
1315            public static int countByP_NotS(long plid, int status)
1316                    throws com.liferay.portal.kernel.exception.SystemException {
1317                    return getPersistence().countByP_NotS(plid, status);
1318            }
1319    
1320            /**
1321            * Returns all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1322            *
1323            * @param layoutSetBranchId the layout set branch ID
1324            * @param layoutBranchId the layout branch ID
1325            * @param plid the plid
1326            * @return the matching layout revisions
1327            * @throws SystemException if a system exception occurred
1328            */
1329            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P(
1330                    long layoutSetBranchId, long layoutBranchId, long plid)
1331                    throws com.liferay.portal.kernel.exception.SystemException {
1332                    return getPersistence()
1333                                       .findByL_L_P(layoutSetBranchId, layoutBranchId, plid);
1334            }
1335    
1336            /**
1337            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1338            *
1339            * <p>
1340            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1341            * </p>
1342            *
1343            * @param layoutSetBranchId the layout set branch ID
1344            * @param layoutBranchId the layout branch ID
1345            * @param plid the plid
1346            * @param start the lower bound of the range of layout revisions
1347            * @param end the upper bound of the range of layout revisions (not inclusive)
1348            * @return the range of matching layout revisions
1349            * @throws SystemException if a system exception occurred
1350            */
1351            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P(
1352                    long layoutSetBranchId, long layoutBranchId, long plid, int start,
1353                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence()
1355                                       .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start,
1356                            end);
1357            }
1358    
1359            /**
1360            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1361            *
1362            * <p>
1363            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1364            * </p>
1365            *
1366            * @param layoutSetBranchId the layout set branch ID
1367            * @param layoutBranchId the layout branch ID
1368            * @param plid the plid
1369            * @param start the lower bound of the range of layout revisions
1370            * @param end the upper bound of the range of layout revisions (not inclusive)
1371            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1372            * @return the ordered range of matching layout revisions
1373            * @throws SystemException if a system exception occurred
1374            */
1375            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P(
1376                    long layoutSetBranchId, long layoutBranchId, long plid, int start,
1377                    int end,
1378                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1379                    throws com.liferay.portal.kernel.exception.SystemException {
1380                    return getPersistence()
1381                                       .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start,
1382                            end, orderByComparator);
1383            }
1384    
1385            /**
1386            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1387            *
1388            * @param layoutSetBranchId the layout set branch ID
1389            * @param layoutBranchId the layout branch ID
1390            * @param plid the plid
1391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1392            * @return the first matching layout revision
1393            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1394            * @throws SystemException if a system exception occurred
1395            */
1396            public static com.liferay.portal.model.LayoutRevision findByL_L_P_First(
1397                    long layoutSetBranchId, long layoutBranchId, long plid,
1398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1399                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1400                            com.liferay.portal.kernel.exception.SystemException {
1401                    return getPersistence()
1402                                       .findByL_L_P_First(layoutSetBranchId, layoutBranchId, plid,
1403                            orderByComparator);
1404            }
1405    
1406            /**
1407            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1408            *
1409            * @param layoutSetBranchId the layout set branch ID
1410            * @param layoutBranchId the layout branch ID
1411            * @param plid the plid
1412            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1413            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1414            * @throws SystemException if a system exception occurred
1415            */
1416            public static com.liferay.portal.model.LayoutRevision fetchByL_L_P_First(
1417                    long layoutSetBranchId, long layoutBranchId, long plid,
1418                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1419                    throws com.liferay.portal.kernel.exception.SystemException {
1420                    return getPersistence()
1421                                       .fetchByL_L_P_First(layoutSetBranchId, layoutBranchId, plid,
1422                            orderByComparator);
1423            }
1424    
1425            /**
1426            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1427            *
1428            * @param layoutSetBranchId the layout set branch ID
1429            * @param layoutBranchId the layout branch ID
1430            * @param plid the plid
1431            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1432            * @return the last matching layout revision
1433            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1434            * @throws SystemException if a system exception occurred
1435            */
1436            public static com.liferay.portal.model.LayoutRevision findByL_L_P_Last(
1437                    long layoutSetBranchId, long layoutBranchId, long plid,
1438                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1439                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1440                            com.liferay.portal.kernel.exception.SystemException {
1441                    return getPersistence()
1442                                       .findByL_L_P_Last(layoutSetBranchId, layoutBranchId, plid,
1443                            orderByComparator);
1444            }
1445    
1446            /**
1447            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1448            *
1449            * @param layoutSetBranchId the layout set branch ID
1450            * @param layoutBranchId the layout branch ID
1451            * @param plid the plid
1452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1453            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1454            * @throws SystemException if a system exception occurred
1455            */
1456            public static com.liferay.portal.model.LayoutRevision fetchByL_L_P_Last(
1457                    long layoutSetBranchId, long layoutBranchId, long plid,
1458                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1459                    throws com.liferay.portal.kernel.exception.SystemException {
1460                    return getPersistence()
1461                                       .fetchByL_L_P_Last(layoutSetBranchId, layoutBranchId, plid,
1462                            orderByComparator);
1463            }
1464    
1465            /**
1466            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1467            *
1468            * @param layoutRevisionId the primary key of the current layout revision
1469            * @param layoutSetBranchId the layout set branch ID
1470            * @param layoutBranchId the layout branch ID
1471            * @param plid the plid
1472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1473            * @return the previous, current, and next layout revision
1474            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1475            * @throws SystemException if a system exception occurred
1476            */
1477            public static com.liferay.portal.model.LayoutRevision[] findByL_L_P_PrevAndNext(
1478                    long layoutRevisionId, long layoutSetBranchId, long layoutBranchId,
1479                    long plid,
1480                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1481                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1482                            com.liferay.portal.kernel.exception.SystemException {
1483                    return getPersistence()
1484                                       .findByL_L_P_PrevAndNext(layoutRevisionId,
1485                            layoutSetBranchId, layoutBranchId, plid, orderByComparator);
1486            }
1487    
1488            /**
1489            * Removes all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63; from the database.
1490            *
1491            * @param layoutSetBranchId the layout set branch ID
1492            * @param layoutBranchId the layout branch ID
1493            * @param plid the plid
1494            * @throws SystemException if a system exception occurred
1495            */
1496            public static void removeByL_L_P(long layoutSetBranchId,
1497                    long layoutBranchId, long plid)
1498                    throws com.liferay.portal.kernel.exception.SystemException {
1499                    getPersistence().removeByL_L_P(layoutSetBranchId, layoutBranchId, plid);
1500            }
1501    
1502            /**
1503            * Returns the number of layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1504            *
1505            * @param layoutSetBranchId the layout set branch ID
1506            * @param layoutBranchId the layout branch ID
1507            * @param plid the plid
1508            * @return the number of matching layout revisions
1509            * @throws SystemException if a system exception occurred
1510            */
1511            public static int countByL_L_P(long layoutSetBranchId, long layoutBranchId,
1512                    long plid) throws com.liferay.portal.kernel.exception.SystemException {
1513                    return getPersistence()
1514                                       .countByL_L_P(layoutSetBranchId, layoutBranchId, plid);
1515            }
1516    
1517            /**
1518            * Returns all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1519            *
1520            * @param layoutSetBranchId the layout set branch ID
1521            * @param parentLayoutRevisionId the parent layout revision ID
1522            * @param plid the plid
1523            * @return the matching layout revisions
1524            * @throws SystemException if a system exception occurred
1525            */
1526            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P(
1527                    long layoutSetBranchId, long parentLayoutRevisionId, long plid)
1528                    throws com.liferay.portal.kernel.exception.SystemException {
1529                    return getPersistence()
1530                                       .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid);
1531            }
1532    
1533            /**
1534            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1535            *
1536            * <p>
1537            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1538            * </p>
1539            *
1540            * @param layoutSetBranchId the layout set branch ID
1541            * @param parentLayoutRevisionId the parent layout revision ID
1542            * @param plid the plid
1543            * @param start the lower bound of the range of layout revisions
1544            * @param end the upper bound of the range of layout revisions (not inclusive)
1545            * @return the range of matching layout revisions
1546            * @throws SystemException if a system exception occurred
1547            */
1548            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P(
1549                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1550                    int start, int end)
1551                    throws com.liferay.portal.kernel.exception.SystemException {
1552                    return getPersistence()
1553                                       .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId,
1554                            plid, start, end);
1555            }
1556    
1557            /**
1558            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1559            *
1560            * <p>
1561            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1562            * </p>
1563            *
1564            * @param layoutSetBranchId the layout set branch ID
1565            * @param parentLayoutRevisionId the parent layout revision ID
1566            * @param plid the plid
1567            * @param start the lower bound of the range of layout revisions
1568            * @param end the upper bound of the range of layout revisions (not inclusive)
1569            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1570            * @return the ordered range of matching layout revisions
1571            * @throws SystemException if a system exception occurred
1572            */
1573            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P(
1574                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1575                    int start, int end,
1576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1577                    throws com.liferay.portal.kernel.exception.SystemException {
1578                    return getPersistence()
1579                                       .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId,
1580                            plid, start, end, orderByComparator);
1581            }
1582    
1583            /**
1584            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1585            *
1586            * @param layoutSetBranchId the layout set branch ID
1587            * @param parentLayoutRevisionId the parent layout revision ID
1588            * @param plid the plid
1589            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1590            * @return the first matching layout revision
1591            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1592            * @throws SystemException if a system exception occurred
1593            */
1594            public static com.liferay.portal.model.LayoutRevision findByL_P_P_First(
1595                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1596                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1597                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1598                            com.liferay.portal.kernel.exception.SystemException {
1599                    return getPersistence()
1600                                       .findByL_P_P_First(layoutSetBranchId,
1601                            parentLayoutRevisionId, plid, orderByComparator);
1602            }
1603    
1604            /**
1605            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1606            *
1607            * @param layoutSetBranchId the layout set branch ID
1608            * @param parentLayoutRevisionId the parent layout revision ID
1609            * @param plid the plid
1610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1611            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1612            * @throws SystemException if a system exception occurred
1613            */
1614            public static com.liferay.portal.model.LayoutRevision fetchByL_P_P_First(
1615                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1616                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1617                    throws com.liferay.portal.kernel.exception.SystemException {
1618                    return getPersistence()
1619                                       .fetchByL_P_P_First(layoutSetBranchId,
1620                            parentLayoutRevisionId, plid, orderByComparator);
1621            }
1622    
1623            /**
1624            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1625            *
1626            * @param layoutSetBranchId the layout set branch ID
1627            * @param parentLayoutRevisionId the parent layout revision ID
1628            * @param plid the plid
1629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1630            * @return the last matching layout revision
1631            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1632            * @throws SystemException if a system exception occurred
1633            */
1634            public static com.liferay.portal.model.LayoutRevision findByL_P_P_Last(
1635                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1636                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1637                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1638                            com.liferay.portal.kernel.exception.SystemException {
1639                    return getPersistence()
1640                                       .findByL_P_P_Last(layoutSetBranchId, parentLayoutRevisionId,
1641                            plid, orderByComparator);
1642            }
1643    
1644            /**
1645            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1646            *
1647            * @param layoutSetBranchId the layout set branch ID
1648            * @param parentLayoutRevisionId the parent layout revision ID
1649            * @param plid the plid
1650            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1651            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1652            * @throws SystemException if a system exception occurred
1653            */
1654            public static com.liferay.portal.model.LayoutRevision fetchByL_P_P_Last(
1655                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1656                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1657                    throws com.liferay.portal.kernel.exception.SystemException {
1658                    return getPersistence()
1659                                       .fetchByL_P_P_Last(layoutSetBranchId,
1660                            parentLayoutRevisionId, plid, orderByComparator);
1661            }
1662    
1663            /**
1664            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1665            *
1666            * @param layoutRevisionId the primary key of the current layout revision
1667            * @param layoutSetBranchId the layout set branch ID
1668            * @param parentLayoutRevisionId the parent layout revision ID
1669            * @param plid the plid
1670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1671            * @return the previous, current, and next layout revision
1672            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1673            * @throws SystemException if a system exception occurred
1674            */
1675            public static com.liferay.portal.model.LayoutRevision[] findByL_P_P_PrevAndNext(
1676                    long layoutRevisionId, long layoutSetBranchId,
1677                    long parentLayoutRevisionId, long plid,
1678                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1679                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1680                            com.liferay.portal.kernel.exception.SystemException {
1681                    return getPersistence()
1682                                       .findByL_P_P_PrevAndNext(layoutRevisionId,
1683                            layoutSetBranchId, parentLayoutRevisionId, plid, orderByComparator);
1684            }
1685    
1686            /**
1687            * Removes all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63; from the database.
1688            *
1689            * @param layoutSetBranchId the layout set branch ID
1690            * @param parentLayoutRevisionId the parent layout revision ID
1691            * @param plid the plid
1692            * @throws SystemException if a system exception occurred
1693            */
1694            public static void removeByL_P_P(long layoutSetBranchId,
1695                    long parentLayoutRevisionId, long plid)
1696                    throws com.liferay.portal.kernel.exception.SystemException {
1697                    getPersistence()
1698                            .removeByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid);
1699            }
1700    
1701            /**
1702            * Returns the number of layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1703            *
1704            * @param layoutSetBranchId the layout set branch ID
1705            * @param parentLayoutRevisionId the parent layout revision ID
1706            * @param plid the plid
1707            * @return the number of matching layout revisions
1708            * @throws SystemException if a system exception occurred
1709            */
1710            public static int countByL_P_P(long layoutSetBranchId,
1711                    long parentLayoutRevisionId, long plid)
1712                    throws com.liferay.portal.kernel.exception.SystemException {
1713                    return getPersistence()
1714                                       .countByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid);
1715            }
1716    
1717            /**
1718            * Returns the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutRevisionException} if it could not be found.
1719            *
1720            * @param layoutSetBranchId the layout set branch ID
1721            * @param head the head
1722            * @param plid the plid
1723            * @return the matching layout revision
1724            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1725            * @throws SystemException if a system exception occurred
1726            */
1727            public static com.liferay.portal.model.LayoutRevision findByL_H_P(
1728                    long layoutSetBranchId, boolean head, long plid)
1729                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1730                            com.liferay.portal.kernel.exception.SystemException {
1731                    return getPersistence().findByL_H_P(layoutSetBranchId, head, plid);
1732            }
1733    
1734            /**
1735            * 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.
1736            *
1737            * @param layoutSetBranchId the layout set branch ID
1738            * @param head the head
1739            * @param plid the plid
1740            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1741            * @throws SystemException if a system exception occurred
1742            */
1743            public static com.liferay.portal.model.LayoutRevision fetchByL_H_P(
1744                    long layoutSetBranchId, boolean head, long plid)
1745                    throws com.liferay.portal.kernel.exception.SystemException {
1746                    return getPersistence().fetchByL_H_P(layoutSetBranchId, head, plid);
1747            }
1748    
1749            /**
1750            * 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.
1751            *
1752            * @param layoutSetBranchId the layout set branch ID
1753            * @param head the head
1754            * @param plid the plid
1755            * @param retrieveFromCache whether to use the finder cache
1756            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1757            * @throws SystemException if a system exception occurred
1758            */
1759            public static com.liferay.portal.model.LayoutRevision fetchByL_H_P(
1760                    long layoutSetBranchId, boolean head, long plid,
1761                    boolean retrieveFromCache)
1762                    throws com.liferay.portal.kernel.exception.SystemException {
1763                    return getPersistence()
1764                                       .fetchByL_H_P(layoutSetBranchId, head, plid,
1765                            retrieveFromCache);
1766            }
1767    
1768            /**
1769            * Removes the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; from the database.
1770            *
1771            * @param layoutSetBranchId the layout set branch ID
1772            * @param head the head
1773            * @param plid the plid
1774            * @return the layout revision that was removed
1775            * @throws SystemException if a system exception occurred
1776            */
1777            public static com.liferay.portal.model.LayoutRevision removeByL_H_P(
1778                    long layoutSetBranchId, boolean head, long plid)
1779                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1780                            com.liferay.portal.kernel.exception.SystemException {
1781                    return getPersistence().removeByL_H_P(layoutSetBranchId, head, plid);
1782            }
1783    
1784            /**
1785            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63; and plid = &#63;.
1786            *
1787            * @param layoutSetBranchId the layout set branch ID
1788            * @param head the head
1789            * @param plid the plid
1790            * @return the number of matching layout revisions
1791            * @throws SystemException if a system exception occurred
1792            */
1793            public static int countByL_H_P(long layoutSetBranchId, boolean head,
1794                    long plid) throws com.liferay.portal.kernel.exception.SystemException {
1795                    return getPersistence().countByL_H_P(layoutSetBranchId, head, plid);
1796            }
1797    
1798            /**
1799            * Returns all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1800            *
1801            * @param layoutSetBranchId the layout set branch ID
1802            * @param plid the plid
1803            * @param status the status
1804            * @return the matching layout revisions
1805            * @throws SystemException if a system exception occurred
1806            */
1807            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S(
1808                    long layoutSetBranchId, long plid, int status)
1809                    throws com.liferay.portal.kernel.exception.SystemException {
1810                    return getPersistence().findByL_P_S(layoutSetBranchId, plid, status);
1811            }
1812    
1813            /**
1814            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1815            *
1816            * <p>
1817            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1818            * </p>
1819            *
1820            * @param layoutSetBranchId the layout set branch ID
1821            * @param plid the plid
1822            * @param status the status
1823            * @param start the lower bound of the range of layout revisions
1824            * @param end the upper bound of the range of layout revisions (not inclusive)
1825            * @return the range of matching layout revisions
1826            * @throws SystemException if a system exception occurred
1827            */
1828            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S(
1829                    long layoutSetBranchId, long plid, int status, int start, int end)
1830                    throws com.liferay.portal.kernel.exception.SystemException {
1831                    return getPersistence()
1832                                       .findByL_P_S(layoutSetBranchId, plid, status, start, end);
1833            }
1834    
1835            /**
1836            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1837            *
1838            * <p>
1839            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
1840            * </p>
1841            *
1842            * @param layoutSetBranchId the layout set branch ID
1843            * @param plid the plid
1844            * @param status the status
1845            * @param start the lower bound of the range of layout revisions
1846            * @param end the upper bound of the range of layout revisions (not inclusive)
1847            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1848            * @return the ordered range of matching layout revisions
1849            * @throws SystemException if a system exception occurred
1850            */
1851            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S(
1852                    long layoutSetBranchId, long plid, int status, int start, int end,
1853                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1854                    throws com.liferay.portal.kernel.exception.SystemException {
1855                    return getPersistence()
1856                                       .findByL_P_S(layoutSetBranchId, plid, status, start, end,
1857                            orderByComparator);
1858            }
1859    
1860            /**
1861            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1862            *
1863            * @param layoutSetBranchId the layout set branch ID
1864            * @param plid the plid
1865            * @param status the status
1866            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1867            * @return the first matching layout revision
1868            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1869            * @throws SystemException if a system exception occurred
1870            */
1871            public static com.liferay.portal.model.LayoutRevision findByL_P_S_First(
1872                    long layoutSetBranchId, long plid, int status,
1873                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1874                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1875                            com.liferay.portal.kernel.exception.SystemException {
1876                    return getPersistence()
1877                                       .findByL_P_S_First(layoutSetBranchId, plid, status,
1878                            orderByComparator);
1879            }
1880    
1881            /**
1882            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1883            *
1884            * @param layoutSetBranchId the layout set branch ID
1885            * @param plid the plid
1886            * @param status the status
1887            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1888            * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found
1889            * @throws SystemException if a system exception occurred
1890            */
1891            public static com.liferay.portal.model.LayoutRevision fetchByL_P_S_First(
1892                    long layoutSetBranchId, long plid, int status,
1893                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1894                    throws com.liferay.portal.kernel.exception.SystemException {
1895                    return getPersistence()
1896                                       .fetchByL_P_S_First(layoutSetBranchId, plid, status,
1897                            orderByComparator);
1898            }
1899    
1900            /**
1901            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1902            *
1903            * @param layoutSetBranchId the layout set branch ID
1904            * @param plid the plid
1905            * @param status the status
1906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1907            * @return the last matching layout revision
1908            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1909            * @throws SystemException if a system exception occurred
1910            */
1911            public static com.liferay.portal.model.LayoutRevision findByL_P_S_Last(
1912                    long layoutSetBranchId, long plid, int status,
1913                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1914                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1915                            com.liferay.portal.kernel.exception.SystemException {
1916                    return getPersistence()
1917                                       .findByL_P_S_Last(layoutSetBranchId, plid, status,
1918                            orderByComparator);
1919            }
1920    
1921            /**
1922            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1923            *
1924            * @param layoutSetBranchId the layout set branch ID
1925            * @param plid the plid
1926            * @param status the status
1927            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1928            * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found
1929            * @throws SystemException if a system exception occurred
1930            */
1931            public static com.liferay.portal.model.LayoutRevision fetchByL_P_S_Last(
1932                    long layoutSetBranchId, long plid, int status,
1933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1934                    throws com.liferay.portal.kernel.exception.SystemException {
1935                    return getPersistence()
1936                                       .fetchByL_P_S_Last(layoutSetBranchId, plid, status,
1937                            orderByComparator);
1938            }
1939    
1940            /**
1941            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1942            *
1943            * @param layoutRevisionId the primary key of the current layout revision
1944            * @param layoutSetBranchId the layout set branch ID
1945            * @param plid the plid
1946            * @param status the status
1947            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1948            * @return the previous, current, and next layout revision
1949            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1950            * @throws SystemException if a system exception occurred
1951            */
1952            public static com.liferay.portal.model.LayoutRevision[] findByL_P_S_PrevAndNext(
1953                    long layoutRevisionId, long layoutSetBranchId, long plid, int status,
1954                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1955                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1956                            com.liferay.portal.kernel.exception.SystemException {
1957                    return getPersistence()
1958                                       .findByL_P_S_PrevAndNext(layoutRevisionId,
1959                            layoutSetBranchId, plid, status, orderByComparator);
1960            }
1961    
1962            /**
1963            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63; from the database.
1964            *
1965            * @param layoutSetBranchId the layout set branch ID
1966            * @param plid the plid
1967            * @param status the status
1968            * @throws SystemException if a system exception occurred
1969            */
1970            public static void removeByL_P_S(long layoutSetBranchId, long plid,
1971                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1972                    getPersistence().removeByL_P_S(layoutSetBranchId, plid, status);
1973            }
1974    
1975            /**
1976            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1977            *
1978            * @param layoutSetBranchId the layout set branch ID
1979            * @param plid the plid
1980            * @param status the status
1981            * @return the number of matching layout revisions
1982            * @throws SystemException if a system exception occurred
1983            */
1984            public static int countByL_P_S(long layoutSetBranchId, long plid, int status)
1985                    throws com.liferay.portal.kernel.exception.SystemException {
1986                    return getPersistence().countByL_P_S(layoutSetBranchId, plid, status);
1987            }
1988    
1989            /**
1990            * Caches the layout revision in the entity cache if it is enabled.
1991            *
1992            * @param layoutRevision the layout revision
1993            */
1994            public static void cacheResult(
1995                    com.liferay.portal.model.LayoutRevision layoutRevision) {
1996                    getPersistence().cacheResult(layoutRevision);
1997            }
1998    
1999            /**
2000            * Caches the layout revisions in the entity cache if it is enabled.
2001            *
2002            * @param layoutRevisions the layout revisions
2003            */
2004            public static void cacheResult(
2005                    java.util.List<com.liferay.portal.model.LayoutRevision> layoutRevisions) {
2006                    getPersistence().cacheResult(layoutRevisions);
2007            }
2008    
2009            /**
2010            * Creates a new layout revision with the primary key. Does not add the layout revision to the database.
2011            *
2012            * @param layoutRevisionId the primary key for the new layout revision
2013            * @return the new layout revision
2014            */
2015            public static com.liferay.portal.model.LayoutRevision create(
2016                    long layoutRevisionId) {
2017                    return getPersistence().create(layoutRevisionId);
2018            }
2019    
2020            /**
2021            * Removes the layout revision with the primary key from the database. Also notifies the appropriate model listeners.
2022            *
2023            * @param layoutRevisionId the primary key of the layout revision
2024            * @return the layout revision that was removed
2025            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
2026            * @throws SystemException if a system exception occurred
2027            */
2028            public static com.liferay.portal.model.LayoutRevision remove(
2029                    long layoutRevisionId)
2030                    throws com.liferay.portal.NoSuchLayoutRevisionException,
2031                            com.liferay.portal.kernel.exception.SystemException {
2032                    return getPersistence().remove(layoutRevisionId);
2033            }
2034    
2035            public static com.liferay.portal.model.LayoutRevision updateImpl(
2036                    com.liferay.portal.model.LayoutRevision layoutRevision)
2037                    throws com.liferay.portal.kernel.exception.SystemException {
2038                    return getPersistence().updateImpl(layoutRevision);
2039            }
2040    
2041            /**
2042            * Returns the layout revision with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutRevisionException} if it could not be found.
2043            *
2044            * @param layoutRevisionId the primary key of the layout revision
2045            * @return the layout revision
2046            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
2047            * @throws SystemException if a system exception occurred
2048            */
2049            public static com.liferay.portal.model.LayoutRevision findByPrimaryKey(
2050                    long layoutRevisionId)
2051                    throws com.liferay.portal.NoSuchLayoutRevisionException,
2052                            com.liferay.portal.kernel.exception.SystemException {
2053                    return getPersistence().findByPrimaryKey(layoutRevisionId);
2054            }
2055    
2056            /**
2057            * Returns the layout revision with the primary key or returns <code>null</code> if it could not be found.
2058            *
2059            * @param layoutRevisionId the primary key of the layout revision
2060            * @return the layout revision, or <code>null</code> if a layout revision with the primary key could not be found
2061            * @throws SystemException if a system exception occurred
2062            */
2063            public static com.liferay.portal.model.LayoutRevision fetchByPrimaryKey(
2064                    long layoutRevisionId)
2065                    throws com.liferay.portal.kernel.exception.SystemException {
2066                    return getPersistence().fetchByPrimaryKey(layoutRevisionId);
2067            }
2068    
2069            /**
2070            * Returns all the layout revisions.
2071            *
2072            * @return the layout revisions
2073            * @throws SystemException if a system exception occurred
2074            */
2075            public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll()
2076                    throws com.liferay.portal.kernel.exception.SystemException {
2077                    return getPersistence().findAll();
2078            }
2079    
2080            /**
2081            * Returns a range of all the layout revisions.
2082            *
2083            * <p>
2084            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
2085            * </p>
2086            *
2087            * @param start the lower bound of the range of layout revisions
2088            * @param end the upper bound of the range of layout revisions (not inclusive)
2089            * @return the range of layout revisions
2090            * @throws SystemException if a system exception occurred
2091            */
2092            public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll(
2093                    int start, int end)
2094                    throws com.liferay.portal.kernel.exception.SystemException {
2095                    return getPersistence().findAll(start, end);
2096            }
2097    
2098            /**
2099            * Returns an ordered range of all the layout revisions.
2100            *
2101            * <p>
2102            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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.
2103            * </p>
2104            *
2105            * @param start the lower bound of the range of layout revisions
2106            * @param end the upper bound of the range of layout revisions (not inclusive)
2107            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2108            * @return the ordered range of layout revisions
2109            * @throws SystemException if a system exception occurred
2110            */
2111            public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll(
2112                    int start, int end,
2113                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2114                    throws com.liferay.portal.kernel.exception.SystemException {
2115                    return getPersistence().findAll(start, end, orderByComparator);
2116            }
2117    
2118            /**
2119            * Removes all the layout revisions from the database.
2120            *
2121            * @throws SystemException if a system exception occurred
2122            */
2123            public static void removeAll()
2124                    throws com.liferay.portal.kernel.exception.SystemException {
2125                    getPersistence().removeAll();
2126            }
2127    
2128            /**
2129            * Returns the number of layout revisions.
2130            *
2131            * @return the number of layout revisions
2132            * @throws SystemException if a system exception occurred
2133            */
2134            public static int countAll()
2135                    throws com.liferay.portal.kernel.exception.SystemException {
2136                    return getPersistence().countAll();
2137            }
2138    
2139            public static LayoutRevisionPersistence getPersistence() {
2140                    if (_persistence == null) {
2141                            _persistence = (LayoutRevisionPersistence)PortalBeanLocatorUtil.locate(LayoutRevisionPersistence.class.getName());
2142    
2143                            ReferenceRegistry.registerReference(LayoutRevisionUtil.class,
2144                                    "_persistence");
2145                    }
2146    
2147                    return _persistence;
2148            }
2149    
2150            /**
2151             * @deprecated As of 6.2.0
2152             */
2153            public void setPersistence(LayoutRevisionPersistence persistence) {
2154            }
2155    
2156            private static LayoutRevisionPersistence _persistence;
2157    }