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