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