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