001    /**
002     * Copyright (c) 2000-2011 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 layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
825            *
826            * @param layoutSetBranchId the layout set branch ID
827            * @param layoutBranchId the layout branch ID
828            * @param plid the plid
829            * @return the matching layout revisions
830            * @throws SystemException if a system exception occurred
831            */
832            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P(
833                    long layoutSetBranchId, long layoutBranchId, long plid)
834                    throws com.liferay.portal.kernel.exception.SystemException {
835                    return getPersistence()
836                                       .findByL_L_P(layoutSetBranchId, layoutBranchId, plid);
837            }
838    
839            /**
840            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
841            *
842            * <p>
843            * 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.
844            * </p>
845            *
846            * @param layoutSetBranchId the layout set branch ID
847            * @param layoutBranchId the layout branch ID
848            * @param plid the plid
849            * @param start the lower bound of the range of layout revisions
850            * @param end the upper bound of the range of layout revisions (not inclusive)
851            * @return the range of matching layout revisions
852            * @throws SystemException if a system exception occurred
853            */
854            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P(
855                    long layoutSetBranchId, long layoutBranchId, long plid, int start,
856                    int end) throws com.liferay.portal.kernel.exception.SystemException {
857                    return getPersistence()
858                                       .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start,
859                            end);
860            }
861    
862            /**
863            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
864            *
865            * <p>
866            * 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.
867            * </p>
868            *
869            * @param layoutSetBranchId the layout set branch ID
870            * @param layoutBranchId the layout branch ID
871            * @param plid the plid
872            * @param start the lower bound of the range of layout revisions
873            * @param end the upper bound of the range of layout revisions (not inclusive)
874            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
875            * @return the ordered range of matching layout revisions
876            * @throws SystemException if a system exception occurred
877            */
878            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_L_P(
879                    long layoutSetBranchId, long layoutBranchId, long plid, int start,
880                    int end,
881                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
882                    throws com.liferay.portal.kernel.exception.SystemException {
883                    return getPersistence()
884                                       .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start,
885                            end, orderByComparator);
886            }
887    
888            /**
889            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
890            *
891            * <p>
892            * 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.
893            * </p>
894            *
895            * @param layoutSetBranchId the layout set branch ID
896            * @param layoutBranchId the layout branch ID
897            * @param plid the plid
898            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
899            * @return the first matching layout revision
900            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
901            * @throws SystemException if a system exception occurred
902            */
903            public static com.liferay.portal.model.LayoutRevision findByL_L_P_First(
904                    long layoutSetBranchId, long layoutBranchId, long plid,
905                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
906                    throws com.liferay.portal.NoSuchLayoutRevisionException,
907                            com.liferay.portal.kernel.exception.SystemException {
908                    return getPersistence()
909                                       .findByL_L_P_First(layoutSetBranchId, layoutBranchId, plid,
910                            orderByComparator);
911            }
912    
913            /**
914            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
915            *
916            * <p>
917            * 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.
918            * </p>
919            *
920            * @param layoutSetBranchId the layout set branch ID
921            * @param layoutBranchId the layout branch ID
922            * @param plid the plid
923            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
924            * @return the last matching layout revision
925            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
926            * @throws SystemException if a system exception occurred
927            */
928            public static com.liferay.portal.model.LayoutRevision findByL_L_P_Last(
929                    long layoutSetBranchId, long layoutBranchId, long plid,
930                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
931                    throws com.liferay.portal.NoSuchLayoutRevisionException,
932                            com.liferay.portal.kernel.exception.SystemException {
933                    return getPersistence()
934                                       .findByL_L_P_Last(layoutSetBranchId, layoutBranchId, plid,
935                            orderByComparator);
936            }
937    
938            /**
939            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
940            *
941            * <p>
942            * 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.
943            * </p>
944            *
945            * @param layoutRevisionId the primary key of the current layout revision
946            * @param layoutSetBranchId the layout set branch ID
947            * @param layoutBranchId the layout branch ID
948            * @param plid the plid
949            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
950            * @return the previous, current, and next layout revision
951            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
952            * @throws SystemException if a system exception occurred
953            */
954            public static com.liferay.portal.model.LayoutRevision[] findByL_L_P_PrevAndNext(
955                    long layoutRevisionId, long layoutSetBranchId, long layoutBranchId,
956                    long plid,
957                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
958                    throws com.liferay.portal.NoSuchLayoutRevisionException,
959                            com.liferay.portal.kernel.exception.SystemException {
960                    return getPersistence()
961                                       .findByL_L_P_PrevAndNext(layoutRevisionId,
962                            layoutSetBranchId, layoutBranchId, plid, orderByComparator);
963            }
964    
965            /**
966            * Returns all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
967            *
968            * @param layoutSetBranchId the layout set branch ID
969            * @param parentLayoutRevisionId the parent layout revision ID
970            * @param plid the plid
971            * @return the matching layout revisions
972            * @throws SystemException if a system exception occurred
973            */
974            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P(
975                    long layoutSetBranchId, long parentLayoutRevisionId, long plid)
976                    throws com.liferay.portal.kernel.exception.SystemException {
977                    return getPersistence()
978                                       .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid);
979            }
980    
981            /**
982            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
983            *
984            * <p>
985            * 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.
986            * </p>
987            *
988            * @param layoutSetBranchId the layout set branch ID
989            * @param parentLayoutRevisionId the parent layout revision ID
990            * @param plid the plid
991            * @param start the lower bound of the range of layout revisions
992            * @param end the upper bound of the range of layout revisions (not inclusive)
993            * @return the range of matching layout revisions
994            * @throws SystemException if a system exception occurred
995            */
996            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P(
997                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
998                    int start, int end)
999                    throws com.liferay.portal.kernel.exception.SystemException {
1000                    return getPersistence()
1001                                       .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId,
1002                            plid, start, end);
1003            }
1004    
1005            /**
1006            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1007            *
1008            * <p>
1009            * 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.
1010            * </p>
1011            *
1012            * @param layoutSetBranchId the layout set branch ID
1013            * @param parentLayoutRevisionId the parent layout revision ID
1014            * @param plid the plid
1015            * @param start the lower bound of the range of layout revisions
1016            * @param end the upper bound of the range of layout revisions (not inclusive)
1017            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1018            * @return the ordered range of matching layout revisions
1019            * @throws SystemException if a system exception occurred
1020            */
1021            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_P(
1022                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1023                    int start, int end,
1024                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1025                    throws com.liferay.portal.kernel.exception.SystemException {
1026                    return getPersistence()
1027                                       .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId,
1028                            plid, start, end, orderByComparator);
1029            }
1030    
1031            /**
1032            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1033            *
1034            * <p>
1035            * 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.
1036            * </p>
1037            *
1038            * @param layoutSetBranchId the layout set branch ID
1039            * @param parentLayoutRevisionId the parent layout revision ID
1040            * @param plid the plid
1041            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1042            * @return the first matching layout revision
1043            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static com.liferay.portal.model.LayoutRevision findByL_P_P_First(
1047                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1048                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1049                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1050                            com.liferay.portal.kernel.exception.SystemException {
1051                    return getPersistence()
1052                                       .findByL_P_P_First(layoutSetBranchId,
1053                            parentLayoutRevisionId, plid, orderByComparator);
1054            }
1055    
1056            /**
1057            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1058            *
1059            * <p>
1060            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1061            * </p>
1062            *
1063            * @param layoutSetBranchId the layout set branch ID
1064            * @param parentLayoutRevisionId the parent layout revision ID
1065            * @param plid the plid
1066            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1067            * @return the last matching layout revision
1068            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1069            * @throws SystemException if a system exception occurred
1070            */
1071            public static com.liferay.portal.model.LayoutRevision findByL_P_P_Last(
1072                    long layoutSetBranchId, long parentLayoutRevisionId, long plid,
1073                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1074                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1075                            com.liferay.portal.kernel.exception.SystemException {
1076                    return getPersistence()
1077                                       .findByL_P_P_Last(layoutSetBranchId, parentLayoutRevisionId,
1078                            plid, orderByComparator);
1079            }
1080    
1081            /**
1082            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1083            *
1084            * <p>
1085            * 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.
1086            * </p>
1087            *
1088            * @param layoutRevisionId the primary key of the current layout revision
1089            * @param layoutSetBranchId the layout set branch ID
1090            * @param parentLayoutRevisionId the parent layout revision ID
1091            * @param plid the plid
1092            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1093            * @return the previous, current, and next layout revision
1094            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1095            * @throws SystemException if a system exception occurred
1096            */
1097            public static com.liferay.portal.model.LayoutRevision[] findByL_P_P_PrevAndNext(
1098                    long layoutRevisionId, long layoutSetBranchId,
1099                    long parentLayoutRevisionId, long plid,
1100                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1101                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1102                            com.liferay.portal.kernel.exception.SystemException {
1103                    return getPersistence()
1104                                       .findByL_P_P_PrevAndNext(layoutRevisionId,
1105                            layoutSetBranchId, parentLayoutRevisionId, plid, orderByComparator);
1106            }
1107    
1108            /**
1109            * 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.
1110            *
1111            * @param layoutSetBranchId the layout set branch ID
1112            * @param head the head
1113            * @param plid the plid
1114            * @return the matching layout revision
1115            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1116            * @throws SystemException if a system exception occurred
1117            */
1118            public static com.liferay.portal.model.LayoutRevision findByL_H_P(
1119                    long layoutSetBranchId, boolean head, long plid)
1120                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1121                            com.liferay.portal.kernel.exception.SystemException {
1122                    return getPersistence().findByL_H_P(layoutSetBranchId, head, plid);
1123            }
1124    
1125            /**
1126            * 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.
1127            *
1128            * @param layoutSetBranchId the layout set branch ID
1129            * @param head the head
1130            * @param plid the plid
1131            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1132            * @throws SystemException if a system exception occurred
1133            */
1134            public static com.liferay.portal.model.LayoutRevision fetchByL_H_P(
1135                    long layoutSetBranchId, boolean head, long plid)
1136                    throws com.liferay.portal.kernel.exception.SystemException {
1137                    return getPersistence().fetchByL_H_P(layoutSetBranchId, head, plid);
1138            }
1139    
1140            /**
1141            * 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.
1142            *
1143            * @param layoutSetBranchId the layout set branch ID
1144            * @param head the head
1145            * @param plid the plid
1146            * @param retrieveFromCache whether to use the finder cache
1147            * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found
1148            * @throws SystemException if a system exception occurred
1149            */
1150            public static com.liferay.portal.model.LayoutRevision fetchByL_H_P(
1151                    long layoutSetBranchId, boolean head, long plid,
1152                    boolean retrieveFromCache)
1153                    throws com.liferay.portal.kernel.exception.SystemException {
1154                    return getPersistence()
1155                                       .fetchByL_H_P(layoutSetBranchId, head, plid,
1156                            retrieveFromCache);
1157            }
1158    
1159            /**
1160            * Returns all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1161            *
1162            * @param layoutSetBranchId the layout set branch ID
1163            * @param plid the plid
1164            * @param status the status
1165            * @return the matching layout revisions
1166            * @throws SystemException if a system exception occurred
1167            */
1168            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S(
1169                    long layoutSetBranchId, long plid, int status)
1170                    throws com.liferay.portal.kernel.exception.SystemException {
1171                    return getPersistence().findByL_P_S(layoutSetBranchId, plid, status);
1172            }
1173    
1174            /**
1175            * Returns a range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1176            *
1177            * <p>
1178            * 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.
1179            * </p>
1180            *
1181            * @param layoutSetBranchId the layout set branch ID
1182            * @param plid the plid
1183            * @param status the status
1184            * @param start the lower bound of the range of layout revisions
1185            * @param end the upper bound of the range of layout revisions (not inclusive)
1186            * @return the range of matching layout revisions
1187            * @throws SystemException if a system exception occurred
1188            */
1189            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S(
1190                    long layoutSetBranchId, long plid, int status, int start, int end)
1191                    throws com.liferay.portal.kernel.exception.SystemException {
1192                    return getPersistence()
1193                                       .findByL_P_S(layoutSetBranchId, plid, status, start, end);
1194            }
1195    
1196            /**
1197            * Returns an ordered range of all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1198            *
1199            * <p>
1200            * 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.
1201            * </p>
1202            *
1203            * @param layoutSetBranchId the layout set branch ID
1204            * @param plid the plid
1205            * @param status the status
1206            * @param start the lower bound of the range of layout revisions
1207            * @param end the upper bound of the range of layout revisions (not inclusive)
1208            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1209            * @return the ordered range of matching layout revisions
1210            * @throws SystemException if a system exception occurred
1211            */
1212            public static java.util.List<com.liferay.portal.model.LayoutRevision> findByL_P_S(
1213                    long layoutSetBranchId, long plid, int status, int start, int end,
1214                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1215                    throws com.liferay.portal.kernel.exception.SystemException {
1216                    return getPersistence()
1217                                       .findByL_P_S(layoutSetBranchId, plid, status, start, end,
1218                            orderByComparator);
1219            }
1220    
1221            /**
1222            * Returns the first layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1223            *
1224            * <p>
1225            * 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.
1226            * </p>
1227            *
1228            * @param layoutSetBranchId the layout set branch ID
1229            * @param plid the plid
1230            * @param status the status
1231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1232            * @return the first matching layout revision
1233            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1234            * @throws SystemException if a system exception occurred
1235            */
1236            public static com.liferay.portal.model.LayoutRevision findByL_P_S_First(
1237                    long layoutSetBranchId, long plid, int status,
1238                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1239                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1240                            com.liferay.portal.kernel.exception.SystemException {
1241                    return getPersistence()
1242                                       .findByL_P_S_First(layoutSetBranchId, plid, status,
1243                            orderByComparator);
1244            }
1245    
1246            /**
1247            * Returns the last layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1248            *
1249            * <p>
1250            * 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.
1251            * </p>
1252            *
1253            * @param layoutSetBranchId the layout set branch ID
1254            * @param plid the plid
1255            * @param status the status
1256            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1257            * @return the last matching layout revision
1258            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a matching layout revision could not be found
1259            * @throws SystemException if a system exception occurred
1260            */
1261            public static com.liferay.portal.model.LayoutRevision findByL_P_S_Last(
1262                    long layoutSetBranchId, long plid, int status,
1263                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1264                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1265                            com.liferay.portal.kernel.exception.SystemException {
1266                    return getPersistence()
1267                                       .findByL_P_S_Last(layoutSetBranchId, plid, status,
1268                            orderByComparator);
1269            }
1270    
1271            /**
1272            * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1273            *
1274            * <p>
1275            * 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.
1276            * </p>
1277            *
1278            * @param layoutRevisionId the primary key of the current layout revision
1279            * @param layoutSetBranchId the layout set branch ID
1280            * @param plid the plid
1281            * @param status the status
1282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1283            * @return the previous, current, and next layout revision
1284            * @throws com.liferay.portal.NoSuchLayoutRevisionException if a layout revision with the primary key could not be found
1285            * @throws SystemException if a system exception occurred
1286            */
1287            public static com.liferay.portal.model.LayoutRevision[] findByL_P_S_PrevAndNext(
1288                    long layoutRevisionId, long layoutSetBranchId, long plid, int status,
1289                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1290                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1291                            com.liferay.portal.kernel.exception.SystemException {
1292                    return getPersistence()
1293                                       .findByL_P_S_PrevAndNext(layoutRevisionId,
1294                            layoutSetBranchId, plid, status, orderByComparator);
1295            }
1296    
1297            /**
1298            * Returns all the layout revisions.
1299            *
1300            * @return the layout revisions
1301            * @throws SystemException if a system exception occurred
1302            */
1303            public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll()
1304                    throws com.liferay.portal.kernel.exception.SystemException {
1305                    return getPersistence().findAll();
1306            }
1307    
1308            /**
1309            * Returns a range of all the layout revisions.
1310            *
1311            * <p>
1312            * 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.
1313            * </p>
1314            *
1315            * @param start the lower bound of the range of layout revisions
1316            * @param end the upper bound of the range of layout revisions (not inclusive)
1317            * @return the range of layout revisions
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll(
1321                    int start, int end)
1322                    throws com.liferay.portal.kernel.exception.SystemException {
1323                    return getPersistence().findAll(start, end);
1324            }
1325    
1326            /**
1327            * Returns an ordered range of all the layout revisions.
1328            *
1329            * <p>
1330            * 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.
1331            * </p>
1332            *
1333            * @param start the lower bound of the range of layout revisions
1334            * @param end the upper bound of the range of layout revisions (not inclusive)
1335            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1336            * @return the ordered range of layout revisions
1337            * @throws SystemException if a system exception occurred
1338            */
1339            public static java.util.List<com.liferay.portal.model.LayoutRevision> findAll(
1340                    int start, int end,
1341                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1342                    throws com.liferay.portal.kernel.exception.SystemException {
1343                    return getPersistence().findAll(start, end, orderByComparator);
1344            }
1345    
1346            /**
1347            * Removes all the layout revisions where layoutSetBranchId = &#63; from the database.
1348            *
1349            * @param layoutSetBranchId the layout set branch ID
1350            * @throws SystemException if a system exception occurred
1351            */
1352            public static void removeByLayoutSetBranchId(long layoutSetBranchId)
1353                    throws com.liferay.portal.kernel.exception.SystemException {
1354                    getPersistence().removeByLayoutSetBranchId(layoutSetBranchId);
1355            }
1356    
1357            /**
1358            * Removes all the layout revisions where plid = &#63; from the database.
1359            *
1360            * @param plid the plid
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static void removeByPlid(long plid)
1364                    throws com.liferay.portal.kernel.exception.SystemException {
1365                    getPersistence().removeByPlid(plid);
1366            }
1367    
1368            /**
1369            * Removes all the layout revisions where layoutSetBranchId = &#63; and head = &#63; from the database.
1370            *
1371            * @param layoutSetBranchId the layout set branch ID
1372            * @param head the head
1373            * @throws SystemException if a system exception occurred
1374            */
1375            public static void removeByL_H(long layoutSetBranchId, boolean head)
1376                    throws com.liferay.portal.kernel.exception.SystemException {
1377                    getPersistence().removeByL_H(layoutSetBranchId, head);
1378            }
1379    
1380            /**
1381            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; from the database.
1382            *
1383            * @param layoutSetBranchId the layout set branch ID
1384            * @param plid the plid
1385            * @throws SystemException if a system exception occurred
1386            */
1387            public static void removeByL_P(long layoutSetBranchId, long plid)
1388                    throws com.liferay.portal.kernel.exception.SystemException {
1389                    getPersistence().removeByL_P(layoutSetBranchId, plid);
1390            }
1391    
1392            /**
1393            * Removes all the layout revisions where layoutSetBranchId = &#63; and status = &#63; from the database.
1394            *
1395            * @param layoutSetBranchId the layout set branch ID
1396            * @param status the status
1397            * @throws SystemException if a system exception occurred
1398            */
1399            public static void removeByL_S(long layoutSetBranchId, int status)
1400                    throws com.liferay.portal.kernel.exception.SystemException {
1401                    getPersistence().removeByL_S(layoutSetBranchId, status);
1402            }
1403    
1404            /**
1405            * Removes all the layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63; from the database.
1406            *
1407            * @param layoutSetBranchId the layout set branch ID
1408            * @param layoutBranchId the layout branch ID
1409            * @param plid the plid
1410            * @throws SystemException if a system exception occurred
1411            */
1412            public static void removeByL_L_P(long layoutSetBranchId,
1413                    long layoutBranchId, long plid)
1414                    throws com.liferay.portal.kernel.exception.SystemException {
1415                    getPersistence().removeByL_L_P(layoutSetBranchId, layoutBranchId, plid);
1416            }
1417    
1418            /**
1419            * Removes all the layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63; from the database.
1420            *
1421            * @param layoutSetBranchId the layout set branch ID
1422            * @param parentLayoutRevisionId the parent layout revision ID
1423            * @param plid the plid
1424            * @throws SystemException if a system exception occurred
1425            */
1426            public static void removeByL_P_P(long layoutSetBranchId,
1427                    long parentLayoutRevisionId, long plid)
1428                    throws com.liferay.portal.kernel.exception.SystemException {
1429                    getPersistence()
1430                            .removeByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid);
1431            }
1432    
1433            /**
1434            * Removes the layout revision where layoutSetBranchId = &#63; and head = &#63; and plid = &#63; from the database.
1435            *
1436            * @param layoutSetBranchId the layout set branch ID
1437            * @param head the head
1438            * @param plid the plid
1439            * @throws SystemException if a system exception occurred
1440            */
1441            public static void removeByL_H_P(long layoutSetBranchId, boolean head,
1442                    long plid)
1443                    throws com.liferay.portal.NoSuchLayoutRevisionException,
1444                            com.liferay.portal.kernel.exception.SystemException {
1445                    getPersistence().removeByL_H_P(layoutSetBranchId, head, plid);
1446            }
1447    
1448            /**
1449            * Removes all the layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63; from the database.
1450            *
1451            * @param layoutSetBranchId the layout set branch ID
1452            * @param plid the plid
1453            * @param status the status
1454            * @throws SystemException if a system exception occurred
1455            */
1456            public static void removeByL_P_S(long layoutSetBranchId, long plid,
1457                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1458                    getPersistence().removeByL_P_S(layoutSetBranchId, plid, status);
1459            }
1460    
1461            /**
1462            * Removes all the layout revisions from the database.
1463            *
1464            * @throws SystemException if a system exception occurred
1465            */
1466            public static void removeAll()
1467                    throws com.liferay.portal.kernel.exception.SystemException {
1468                    getPersistence().removeAll();
1469            }
1470    
1471            /**
1472            * Returns the number of layout revisions where layoutSetBranchId = &#63;.
1473            *
1474            * @param layoutSetBranchId the layout set branch ID
1475            * @return the number of matching layout revisions
1476            * @throws SystemException if a system exception occurred
1477            */
1478            public static int countByLayoutSetBranchId(long layoutSetBranchId)
1479                    throws com.liferay.portal.kernel.exception.SystemException {
1480                    return getPersistence().countByLayoutSetBranchId(layoutSetBranchId);
1481            }
1482    
1483            /**
1484            * Returns the number of layout revisions where plid = &#63;.
1485            *
1486            * @param plid the plid
1487            * @return the number of matching layout revisions
1488            * @throws SystemException if a system exception occurred
1489            */
1490            public static int countByPlid(long plid)
1491                    throws com.liferay.portal.kernel.exception.SystemException {
1492                    return getPersistence().countByPlid(plid);
1493            }
1494    
1495            /**
1496            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63;.
1497            *
1498            * @param layoutSetBranchId the layout set branch ID
1499            * @param head the head
1500            * @return the number of matching layout revisions
1501            * @throws SystemException if a system exception occurred
1502            */
1503            public static int countByL_H(long layoutSetBranchId, boolean head)
1504                    throws com.liferay.portal.kernel.exception.SystemException {
1505                    return getPersistence().countByL_H(layoutSetBranchId, head);
1506            }
1507    
1508            /**
1509            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63;.
1510            *
1511            * @param layoutSetBranchId the layout set branch ID
1512            * @param plid the plid
1513            * @return the number of matching layout revisions
1514            * @throws SystemException if a system exception occurred
1515            */
1516            public static int countByL_P(long layoutSetBranchId, long plid)
1517                    throws com.liferay.portal.kernel.exception.SystemException {
1518                    return getPersistence().countByL_P(layoutSetBranchId, plid);
1519            }
1520    
1521            /**
1522            * Returns the number of layout revisions where layoutSetBranchId = &#63; and status = &#63;.
1523            *
1524            * @param layoutSetBranchId the layout set branch ID
1525            * @param status the status
1526            * @return the number of matching layout revisions
1527            * @throws SystemException if a system exception occurred
1528            */
1529            public static int countByL_S(long layoutSetBranchId, int status)
1530                    throws com.liferay.portal.kernel.exception.SystemException {
1531                    return getPersistence().countByL_S(layoutSetBranchId, status);
1532            }
1533    
1534            /**
1535            * Returns the number of layout revisions where layoutSetBranchId = &#63; and layoutBranchId = &#63; and plid = &#63;.
1536            *
1537            * @param layoutSetBranchId the layout set branch ID
1538            * @param layoutBranchId the layout branch ID
1539            * @param plid the plid
1540            * @return the number of matching layout revisions
1541            * @throws SystemException if a system exception occurred
1542            */
1543            public static int countByL_L_P(long layoutSetBranchId, long layoutBranchId,
1544                    long plid) throws com.liferay.portal.kernel.exception.SystemException {
1545                    return getPersistence()
1546                                       .countByL_L_P(layoutSetBranchId, layoutBranchId, plid);
1547            }
1548    
1549            /**
1550            * Returns the number of layout revisions where layoutSetBranchId = &#63; and parentLayoutRevisionId = &#63; and plid = &#63;.
1551            *
1552            * @param layoutSetBranchId the layout set branch ID
1553            * @param parentLayoutRevisionId the parent layout revision ID
1554            * @param plid the plid
1555            * @return the number of matching layout revisions
1556            * @throws SystemException if a system exception occurred
1557            */
1558            public static int countByL_P_P(long layoutSetBranchId,
1559                    long parentLayoutRevisionId, long plid)
1560                    throws com.liferay.portal.kernel.exception.SystemException {
1561                    return getPersistence()
1562                                       .countByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid);
1563            }
1564    
1565            /**
1566            * Returns the number of layout revisions where layoutSetBranchId = &#63; and head = &#63; and plid = &#63;.
1567            *
1568            * @param layoutSetBranchId the layout set branch ID
1569            * @param head the head
1570            * @param plid the plid
1571            * @return the number of matching layout revisions
1572            * @throws SystemException if a system exception occurred
1573            */
1574            public static int countByL_H_P(long layoutSetBranchId, boolean head,
1575                    long plid) throws com.liferay.portal.kernel.exception.SystemException {
1576                    return getPersistence().countByL_H_P(layoutSetBranchId, head, plid);
1577            }
1578    
1579            /**
1580            * Returns the number of layout revisions where layoutSetBranchId = &#63; and plid = &#63; and status = &#63;.
1581            *
1582            * @param layoutSetBranchId the layout set branch ID
1583            * @param plid the plid
1584            * @param status the status
1585            * @return the number of matching layout revisions
1586            * @throws SystemException if a system exception occurred
1587            */
1588            public static int countByL_P_S(long layoutSetBranchId, long plid, int status)
1589                    throws com.liferay.portal.kernel.exception.SystemException {
1590                    return getPersistence().countByL_P_S(layoutSetBranchId, plid, status);
1591            }
1592    
1593            /**
1594            * Returns the number of layout revisions.
1595            *
1596            * @return the number of layout revisions
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static int countAll()
1600                    throws com.liferay.portal.kernel.exception.SystemException {
1601                    return getPersistence().countAll();
1602            }
1603    
1604            public static LayoutRevisionPersistence getPersistence() {
1605                    if (_persistence == null) {
1606                            _persistence = (LayoutRevisionPersistence)PortalBeanLocatorUtil.locate(LayoutRevisionPersistence.class.getName());
1607    
1608                            ReferenceRegistry.registerReference(LayoutRevisionUtil.class,
1609                                    "_persistence");
1610                    }
1611    
1612                    return _persistence;
1613            }
1614    
1615            public void setPersistence(LayoutRevisionPersistence persistence) {
1616                    _persistence = persistence;
1617    
1618                    ReferenceRegistry.registerReference(LayoutRevisionUtil.class,
1619                            "_persistence");
1620            }
1621    
1622            private static LayoutRevisionPersistence _persistence;
1623    }