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