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