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