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