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