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