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