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