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