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