001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.exception.SystemException;
022    import com.liferay.portal.kernel.util.OrderByComparator;
023    import com.liferay.portal.kernel.util.ReferenceRegistry;
024    import com.liferay.portal.model.Layout;
025    import com.liferay.portal.service.ServiceContext;
026    
027    import java.util.List;
028    
029    /**
030     * 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see LayoutPersistence
038     * @see LayoutPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class LayoutUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(Layout layout) {
060                    getPersistence().clearCache(layout);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
067                    throws SystemException {
068                    return getPersistence().countWithDynamicQuery(dynamicQuery);
069            }
070    
071            /**
072             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
073             */
074            public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
081             */
082            public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery,
083                    int start, int end) throws SystemException {
084                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
085            }
086    
087            /**
088             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
089             */
090            public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery,
091                    int start, int end, OrderByComparator orderByComparator)
092                    throws SystemException {
093                    return getPersistence()
094                                       .findWithDynamicQuery(dynamicQuery, start, end,
095                            orderByComparator);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
100             */
101            public static Layout update(Layout layout) throws SystemException {
102                    return getPersistence().update(layout);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static Layout update(Layout layout, ServiceContext serviceContext)
109                    throws SystemException {
110                    return getPersistence().update(layout, serviceContext);
111            }
112    
113            /**
114            * Returns all the layouts where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching layouts
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the layouts where uuid = &#63;.
128            *
129            * <p>
130            * 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.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of layouts
135            * @param end the upper bound of the range of layouts (not inclusive)
136            * @return the range of matching layouts
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the layouts where uuid = &#63;.
147            *
148            * <p>
149            * 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.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of layouts
154            * @param end the upper bound of the range of layouts (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching layouts
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first layout in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching layout
172            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portal.model.Layout findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.NoSuchLayoutException,
179                            com.liferay.portal.kernel.exception.SystemException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first layout in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portal.model.Layout fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last layout in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching layout
204            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portal.model.Layout findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.NoSuchLayoutException,
211                            com.liferay.portal.kernel.exception.SystemException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last layout in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portal.model.Layout fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the layouts before and after the current layout in the ordered set where uuid = &#63;.
232            *
233            * @param plid the primary key of the current layout
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next layout
237            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portal.model.Layout[] findByUuid_PrevAndNext(
241                    long plid, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.NoSuchLayoutException,
244                            com.liferay.portal.kernel.exception.SystemException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(plid, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the layouts where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of layouts where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching layouts
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * 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.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @param privateLayout the private layout
278            * @return the matching layout
279            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
280            * @throws SystemException if a system exception occurred
281            */
282            public static com.liferay.portal.model.Layout findByUUID_G_P(
283                    java.lang.String uuid, long groupId, boolean privateLayout)
284                    throws com.liferay.portal.NoSuchLayoutException,
285                            com.liferay.portal.kernel.exception.SystemException {
286                    return getPersistence().findByUUID_G_P(uuid, groupId, privateLayout);
287            }
288    
289            /**
290            * 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.
291            *
292            * @param uuid the uuid
293            * @param groupId the group ID
294            * @param privateLayout the private layout
295            * @return the matching layout, or <code>null</code> if a matching layout could not be found
296            * @throws SystemException if a system exception occurred
297            */
298            public static com.liferay.portal.model.Layout fetchByUUID_G_P(
299                    java.lang.String uuid, long groupId, boolean privateLayout)
300                    throws com.liferay.portal.kernel.exception.SystemException {
301                    return getPersistence().fetchByUUID_G_P(uuid, groupId, privateLayout);
302            }
303    
304            /**
305            * 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.
306            *
307            * @param uuid the uuid
308            * @param groupId the group ID
309            * @param privateLayout the private layout
310            * @param retrieveFromCache whether to use the finder cache
311            * @return the matching layout, or <code>null</code> if a matching layout could not be found
312            * @throws SystemException if a system exception occurred
313            */
314            public static com.liferay.portal.model.Layout fetchByUUID_G_P(
315                    java.lang.String uuid, long groupId, boolean privateLayout,
316                    boolean retrieveFromCache)
317                    throws com.liferay.portal.kernel.exception.SystemException {
318                    return getPersistence()
319                                       .fetchByUUID_G_P(uuid, groupId, privateLayout,
320                            retrieveFromCache);
321            }
322    
323            /**
324            * Removes the layout where uuid = &#63; and groupId = &#63; and privateLayout = &#63; from the database.
325            *
326            * @param uuid the uuid
327            * @param groupId the group ID
328            * @param privateLayout the private layout
329            * @return the layout that was removed
330            * @throws SystemException if a system exception occurred
331            */
332            public static com.liferay.portal.model.Layout removeByUUID_G_P(
333                    java.lang.String uuid, long groupId, boolean privateLayout)
334                    throws com.liferay.portal.NoSuchLayoutException,
335                            com.liferay.portal.kernel.exception.SystemException {
336                    return getPersistence().removeByUUID_G_P(uuid, groupId, privateLayout);
337            }
338    
339            /**
340            * Returns the number of layouts where uuid = &#63; and groupId = &#63; and privateLayout = &#63;.
341            *
342            * @param uuid the uuid
343            * @param groupId the group ID
344            * @param privateLayout the private layout
345            * @return the number of matching layouts
346            * @throws SystemException if a system exception occurred
347            */
348            public static int countByUUID_G_P(java.lang.String uuid, long groupId,
349                    boolean privateLayout)
350                    throws com.liferay.portal.kernel.exception.SystemException {
351                    return getPersistence().countByUUID_G_P(uuid, groupId, privateLayout);
352            }
353    
354            /**
355            * Returns all the layouts where uuid = &#63; and companyId = &#63;.
356            *
357            * @param uuid the uuid
358            * @param companyId the company ID
359            * @return the matching layouts
360            * @throws SystemException if a system exception occurred
361            */
362            public static java.util.List<com.liferay.portal.model.Layout> findByUuid_C(
363                    java.lang.String uuid, long companyId)
364                    throws com.liferay.portal.kernel.exception.SystemException {
365                    return getPersistence().findByUuid_C(uuid, companyId);
366            }
367    
368            /**
369            * Returns a range of all the layouts where uuid = &#63; and companyId = &#63;.
370            *
371            * <p>
372            * 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.
373            * </p>
374            *
375            * @param uuid the uuid
376            * @param companyId the company ID
377            * @param start the lower bound of the range of layouts
378            * @param end the upper bound of the range of layouts (not inclusive)
379            * @return the range of matching layouts
380            * @throws SystemException if a system exception occurred
381            */
382            public static java.util.List<com.liferay.portal.model.Layout> findByUuid_C(
383                    java.lang.String uuid, long companyId, int start, int end)
384                    throws com.liferay.portal.kernel.exception.SystemException {
385                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
386            }
387    
388            /**
389            * Returns an ordered range of all the layouts where uuid = &#63; and companyId = &#63;.
390            *
391            * <p>
392            * 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.
393            * </p>
394            *
395            * @param uuid the uuid
396            * @param companyId the company ID
397            * @param start the lower bound of the range of layouts
398            * @param end the upper bound of the range of layouts (not inclusive)
399            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
400            * @return the ordered range of matching layouts
401            * @throws SystemException if a system exception occurred
402            */
403            public static java.util.List<com.liferay.portal.model.Layout> findByUuid_C(
404                    java.lang.String uuid, long companyId, int start, int end,
405                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
406                    throws com.liferay.portal.kernel.exception.SystemException {
407                    return getPersistence()
408                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
409            }
410    
411            /**
412            * Returns the first layout in the ordered set where uuid = &#63; and companyId = &#63;.
413            *
414            * @param uuid the uuid
415            * @param companyId the company ID
416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
417            * @return the first matching layout
418            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
419            * @throws SystemException if a system exception occurred
420            */
421            public static com.liferay.portal.model.Layout findByUuid_C_First(
422                    java.lang.String uuid, long companyId,
423                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
424                    throws com.liferay.portal.NoSuchLayoutException,
425                            com.liferay.portal.kernel.exception.SystemException {
426                    return getPersistence()
427                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
428            }
429    
430            /**
431            * Returns the first layout in the ordered set where uuid = &#63; and companyId = &#63;.
432            *
433            * @param uuid the uuid
434            * @param companyId the company ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
437            * @throws SystemException if a system exception occurred
438            */
439            public static com.liferay.portal.model.Layout fetchByUuid_C_First(
440                    java.lang.String uuid, long companyId,
441                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
442                    throws com.liferay.portal.kernel.exception.SystemException {
443                    return getPersistence()
444                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
445            }
446    
447            /**
448            * Returns the last layout in the ordered set where uuid = &#63; and companyId = &#63;.
449            *
450            * @param uuid the uuid
451            * @param companyId the company ID
452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
453            * @return the last matching layout
454            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
455            * @throws SystemException if a system exception occurred
456            */
457            public static com.liferay.portal.model.Layout findByUuid_C_Last(
458                    java.lang.String uuid, long companyId,
459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
460                    throws com.liferay.portal.NoSuchLayoutException,
461                            com.liferay.portal.kernel.exception.SystemException {
462                    return getPersistence()
463                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
464            }
465    
466            /**
467            * Returns the last layout in the ordered set where uuid = &#63; and companyId = &#63;.
468            *
469            * @param uuid the uuid
470            * @param companyId the company ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
473            * @throws SystemException if a system exception occurred
474            */
475            public static com.liferay.portal.model.Layout fetchByUuid_C_Last(
476                    java.lang.String uuid, long companyId,
477                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
478                    throws com.liferay.portal.kernel.exception.SystemException {
479                    return getPersistence()
480                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
481            }
482    
483            /**
484            * Returns the layouts before and after the current layout in the ordered set where uuid = &#63; and companyId = &#63;.
485            *
486            * @param plid the primary key of the current layout
487            * @param uuid the uuid
488            * @param companyId the company ID
489            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
490            * @return the previous, current, and next layout
491            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
492            * @throws SystemException if a system exception occurred
493            */
494            public static com.liferay.portal.model.Layout[] findByUuid_C_PrevAndNext(
495                    long plid, java.lang.String uuid, long companyId,
496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
497                    throws com.liferay.portal.NoSuchLayoutException,
498                            com.liferay.portal.kernel.exception.SystemException {
499                    return getPersistence()
500                                       .findByUuid_C_PrevAndNext(plid, uuid, companyId,
501                            orderByComparator);
502            }
503    
504            /**
505            * Removes all the layouts where uuid = &#63; and companyId = &#63; from the database.
506            *
507            * @param uuid the uuid
508            * @param companyId the company ID
509            * @throws SystemException if a system exception occurred
510            */
511            public static void removeByUuid_C(java.lang.String uuid, long companyId)
512                    throws com.liferay.portal.kernel.exception.SystemException {
513                    getPersistence().removeByUuid_C(uuid, companyId);
514            }
515    
516            /**
517            * Returns the number of layouts where uuid = &#63; and companyId = &#63;.
518            *
519            * @param uuid the uuid
520            * @param companyId the company ID
521            * @return the number of matching layouts
522            * @throws SystemException if a system exception occurred
523            */
524            public static int countByUuid_C(java.lang.String uuid, long companyId)
525                    throws com.liferay.portal.kernel.exception.SystemException {
526                    return getPersistence().countByUuid_C(uuid, companyId);
527            }
528    
529            /**
530            * Returns all the layouts where groupId = &#63;.
531            *
532            * @param groupId the group ID
533            * @return the matching layouts
534            * @throws SystemException if a system exception occurred
535            */
536            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
537                    long groupId)
538                    throws com.liferay.portal.kernel.exception.SystemException {
539                    return getPersistence().findByGroupId(groupId);
540            }
541    
542            /**
543            * Returns a range of all the layouts where groupId = &#63;.
544            *
545            * <p>
546            * 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.
547            * </p>
548            *
549            * @param groupId the group ID
550            * @param start the lower bound of the range of layouts
551            * @param end the upper bound of the range of layouts (not inclusive)
552            * @return the range of matching layouts
553            * @throws SystemException if a system exception occurred
554            */
555            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
556                    long groupId, int start, int end)
557                    throws com.liferay.portal.kernel.exception.SystemException {
558                    return getPersistence().findByGroupId(groupId, start, end);
559            }
560    
561            /**
562            * Returns an ordered range of all the layouts where groupId = &#63;.
563            *
564            * <p>
565            * 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.
566            * </p>
567            *
568            * @param groupId the group ID
569            * @param start the lower bound of the range of layouts
570            * @param end the upper bound of the range of layouts (not inclusive)
571            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
572            * @return the ordered range of matching layouts
573            * @throws SystemException if a system exception occurred
574            */
575            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
576                    long groupId, int start, int end,
577                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
578                    throws com.liferay.portal.kernel.exception.SystemException {
579                    return getPersistence()
580                                       .findByGroupId(groupId, start, end, orderByComparator);
581            }
582    
583            /**
584            * Returns the first layout in the ordered set where groupId = &#63;.
585            *
586            * @param groupId the group ID
587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
588            * @return the first matching layout
589            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
590            * @throws SystemException if a system exception occurred
591            */
592            public static com.liferay.portal.model.Layout findByGroupId_First(
593                    long groupId,
594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
595                    throws com.liferay.portal.NoSuchLayoutException,
596                            com.liferay.portal.kernel.exception.SystemException {
597                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
598            }
599    
600            /**
601            * Returns the first layout in the ordered set where groupId = &#63;.
602            *
603            * @param groupId the group ID
604            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
605            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
606            * @throws SystemException if a system exception occurred
607            */
608            public static com.liferay.portal.model.Layout fetchByGroupId_First(
609                    long groupId,
610                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
611                    throws com.liferay.portal.kernel.exception.SystemException {
612                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
613            }
614    
615            /**
616            * Returns the last layout in the ordered set where groupId = &#63;.
617            *
618            * @param groupId the group ID
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the last matching layout
621            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
622            * @throws SystemException if a system exception occurred
623            */
624            public static com.liferay.portal.model.Layout findByGroupId_Last(
625                    long groupId,
626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
627                    throws com.liferay.portal.NoSuchLayoutException,
628                            com.liferay.portal.kernel.exception.SystemException {
629                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
630            }
631    
632            /**
633            * Returns the last layout in the ordered set where groupId = &#63;.
634            *
635            * @param groupId the group ID
636            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
637            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
638            * @throws SystemException if a system exception occurred
639            */
640            public static com.liferay.portal.model.Layout fetchByGroupId_Last(
641                    long groupId,
642                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
643                    throws com.liferay.portal.kernel.exception.SystemException {
644                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
645            }
646    
647            /**
648            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63;.
649            *
650            * @param plid the primary key of the current layout
651            * @param groupId the group ID
652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
653            * @return the previous, current, and next layout
654            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
655            * @throws SystemException if a system exception occurred
656            */
657            public static com.liferay.portal.model.Layout[] findByGroupId_PrevAndNext(
658                    long plid, long groupId,
659                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
660                    throws com.liferay.portal.NoSuchLayoutException,
661                            com.liferay.portal.kernel.exception.SystemException {
662                    return getPersistence()
663                                       .findByGroupId_PrevAndNext(plid, groupId, orderByComparator);
664            }
665    
666            /**
667            * Returns all the layouts that the user has permission to view where groupId = &#63;.
668            *
669            * @param groupId the group ID
670            * @return the matching layouts that the user has permission to view
671            * @throws SystemException if a system exception occurred
672            */
673            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
674                    long groupId)
675                    throws com.liferay.portal.kernel.exception.SystemException {
676                    return getPersistence().filterFindByGroupId(groupId);
677            }
678    
679            /**
680            * Returns a range of all the layouts that the user has permission to view where groupId = &#63;.
681            *
682            * <p>
683            * 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.
684            * </p>
685            *
686            * @param groupId the group ID
687            * @param start the lower bound of the range of layouts
688            * @param end the upper bound of the range of layouts (not inclusive)
689            * @return the range of matching layouts that the user has permission to view
690            * @throws SystemException if a system exception occurred
691            */
692            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
693                    long groupId, int start, int end)
694                    throws com.liferay.portal.kernel.exception.SystemException {
695                    return getPersistence().filterFindByGroupId(groupId, start, end);
696            }
697    
698            /**
699            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63;.
700            *
701            * <p>
702            * 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.
703            * </p>
704            *
705            * @param groupId the group ID
706            * @param start the lower bound of the range of layouts
707            * @param end the upper bound of the range of layouts (not inclusive)
708            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
709            * @return the ordered range of matching layouts that the user has permission to view
710            * @throws SystemException if a system exception occurred
711            */
712            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
713                    long groupId, int start, int end,
714                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
715                    throws com.liferay.portal.kernel.exception.SystemException {
716                    return getPersistence()
717                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
718            }
719    
720            /**
721            * 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;.
722            *
723            * @param plid the primary key of the current layout
724            * @param groupId the group ID
725            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
726            * @return the previous, current, and next layout
727            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
728            * @throws SystemException if a system exception occurred
729            */
730            public static com.liferay.portal.model.Layout[] filterFindByGroupId_PrevAndNext(
731                    long plid, long groupId,
732                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
733                    throws com.liferay.portal.NoSuchLayoutException,
734                            com.liferay.portal.kernel.exception.SystemException {
735                    return getPersistence()
736                                       .filterFindByGroupId_PrevAndNext(plid, groupId,
737                            orderByComparator);
738            }
739    
740            /**
741            * Removes all the layouts where groupId = &#63; from the database.
742            *
743            * @param groupId the group ID
744            * @throws SystemException if a system exception occurred
745            */
746            public static void removeByGroupId(long groupId)
747                    throws com.liferay.portal.kernel.exception.SystemException {
748                    getPersistence().removeByGroupId(groupId);
749            }
750    
751            /**
752            * Returns the number of layouts where groupId = &#63;.
753            *
754            * @param groupId the group ID
755            * @return the number of matching layouts
756            * @throws SystemException if a system exception occurred
757            */
758            public static int countByGroupId(long groupId)
759                    throws com.liferay.portal.kernel.exception.SystemException {
760                    return getPersistence().countByGroupId(groupId);
761            }
762    
763            /**
764            * Returns the number of layouts that the user has permission to view where groupId = &#63;.
765            *
766            * @param groupId the group ID
767            * @return the number of matching layouts that the user has permission to view
768            * @throws SystemException if a system exception occurred
769            */
770            public static int filterCountByGroupId(long groupId)
771                    throws com.liferay.portal.kernel.exception.SystemException {
772                    return getPersistence().filterCountByGroupId(groupId);
773            }
774    
775            /**
776            * Returns all the layouts where companyId = &#63;.
777            *
778            * @param companyId the company ID
779            * @return the matching layouts
780            * @throws SystemException if a system exception occurred
781            */
782            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
783                    long companyId)
784                    throws com.liferay.portal.kernel.exception.SystemException {
785                    return getPersistence().findByCompanyId(companyId);
786            }
787    
788            /**
789            * Returns a range of all the layouts where companyId = &#63;.
790            *
791            * <p>
792            * 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.
793            * </p>
794            *
795            * @param companyId the company ID
796            * @param start the lower bound of the range of layouts
797            * @param end the upper bound of the range of layouts (not inclusive)
798            * @return the range of matching layouts
799            * @throws SystemException if a system exception occurred
800            */
801            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
802                    long companyId, int start, int end)
803                    throws com.liferay.portal.kernel.exception.SystemException {
804                    return getPersistence().findByCompanyId(companyId, start, end);
805            }
806    
807            /**
808            * Returns an ordered range of all the layouts where companyId = &#63;.
809            *
810            * <p>
811            * 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.
812            * </p>
813            *
814            * @param companyId the company ID
815            * @param start the lower bound of the range of layouts
816            * @param end the upper bound of the range of layouts (not inclusive)
817            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
818            * @return the ordered range of matching layouts
819            * @throws SystemException if a system exception occurred
820            */
821            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
822                    long companyId, int start, int end,
823                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
824                    throws com.liferay.portal.kernel.exception.SystemException {
825                    return getPersistence()
826                                       .findByCompanyId(companyId, start, end, orderByComparator);
827            }
828    
829            /**
830            * Returns the first layout in the ordered set where companyId = &#63;.
831            *
832            * @param companyId the company ID
833            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
834            * @return the first matching layout
835            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
836            * @throws SystemException if a system exception occurred
837            */
838            public static com.liferay.portal.model.Layout findByCompanyId_First(
839                    long companyId,
840                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
841                    throws com.liferay.portal.NoSuchLayoutException,
842                            com.liferay.portal.kernel.exception.SystemException {
843                    return getPersistence()
844                                       .findByCompanyId_First(companyId, orderByComparator);
845            }
846    
847            /**
848            * Returns the first layout in the ordered set where companyId = &#63;.
849            *
850            * @param companyId the company ID
851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
852            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
853            * @throws SystemException if a system exception occurred
854            */
855            public static com.liferay.portal.model.Layout fetchByCompanyId_First(
856                    long companyId,
857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
858                    throws com.liferay.portal.kernel.exception.SystemException {
859                    return getPersistence()
860                                       .fetchByCompanyId_First(companyId, orderByComparator);
861            }
862    
863            /**
864            * Returns the last layout in the ordered set where companyId = &#63;.
865            *
866            * @param companyId the company ID
867            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
868            * @return the last matching layout
869            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
870            * @throws SystemException if a system exception occurred
871            */
872            public static com.liferay.portal.model.Layout findByCompanyId_Last(
873                    long companyId,
874                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
875                    throws com.liferay.portal.NoSuchLayoutException,
876                            com.liferay.portal.kernel.exception.SystemException {
877                    return getPersistence()
878                                       .findByCompanyId_Last(companyId, orderByComparator);
879            }
880    
881            /**
882            * Returns the last layout in the ordered set where companyId = &#63;.
883            *
884            * @param companyId the company ID
885            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
886            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
887            * @throws SystemException if a system exception occurred
888            */
889            public static com.liferay.portal.model.Layout fetchByCompanyId_Last(
890                    long companyId,
891                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
892                    throws com.liferay.portal.kernel.exception.SystemException {
893                    return getPersistence()
894                                       .fetchByCompanyId_Last(companyId, orderByComparator);
895            }
896    
897            /**
898            * Returns the layouts before and after the current layout in the ordered set where companyId = &#63;.
899            *
900            * @param plid the primary key of the current layout
901            * @param companyId the company ID
902            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
903            * @return the previous, current, and next layout
904            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
905            * @throws SystemException if a system exception occurred
906            */
907            public static com.liferay.portal.model.Layout[] findByCompanyId_PrevAndNext(
908                    long plid, long companyId,
909                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
910                    throws com.liferay.portal.NoSuchLayoutException,
911                            com.liferay.portal.kernel.exception.SystemException {
912                    return getPersistence()
913                                       .findByCompanyId_PrevAndNext(plid, companyId,
914                            orderByComparator);
915            }
916    
917            /**
918            * Removes all the layouts where companyId = &#63; from the database.
919            *
920            * @param companyId the company ID
921            * @throws SystemException if a system exception occurred
922            */
923            public static void removeByCompanyId(long companyId)
924                    throws com.liferay.portal.kernel.exception.SystemException {
925                    getPersistence().removeByCompanyId(companyId);
926            }
927    
928            /**
929            * Returns the number of layouts where companyId = &#63;.
930            *
931            * @param companyId the company ID
932            * @return the number of matching layouts
933            * @throws SystemException if a system exception occurred
934            */
935            public static int countByCompanyId(long companyId)
936                    throws com.liferay.portal.kernel.exception.SystemException {
937                    return getPersistence().countByCompanyId(companyId);
938            }
939    
940            /**
941            * Returns the layout where iconImageId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
942            *
943            * @param iconImageId the icon image ID
944            * @return the matching layout
945            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
946            * @throws SystemException if a system exception occurred
947            */
948            public static com.liferay.portal.model.Layout findByIconImageId(
949                    long iconImageId)
950                    throws com.liferay.portal.NoSuchLayoutException,
951                            com.liferay.portal.kernel.exception.SystemException {
952                    return getPersistence().findByIconImageId(iconImageId);
953            }
954    
955            /**
956            * Returns the layout where iconImageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
957            *
958            * @param iconImageId the icon image ID
959            * @return the matching layout, or <code>null</code> if a matching layout could not be found
960            * @throws SystemException if a system exception occurred
961            */
962            public static com.liferay.portal.model.Layout fetchByIconImageId(
963                    long iconImageId)
964                    throws com.liferay.portal.kernel.exception.SystemException {
965                    return getPersistence().fetchByIconImageId(iconImageId);
966            }
967    
968            /**
969            * Returns the layout where iconImageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
970            *
971            * @param iconImageId the icon image ID
972            * @param retrieveFromCache whether to use the finder cache
973            * @return the matching layout, or <code>null</code> if a matching layout could not be found
974            * @throws SystemException if a system exception occurred
975            */
976            public static com.liferay.portal.model.Layout fetchByIconImageId(
977                    long iconImageId, boolean retrieveFromCache)
978                    throws com.liferay.portal.kernel.exception.SystemException {
979                    return getPersistence()
980                                       .fetchByIconImageId(iconImageId, retrieveFromCache);
981            }
982    
983            /**
984            * Removes the layout where iconImageId = &#63; from the database.
985            *
986            * @param iconImageId the icon image ID
987            * @return the layout that was removed
988            * @throws SystemException if a system exception occurred
989            */
990            public static com.liferay.portal.model.Layout removeByIconImageId(
991                    long iconImageId)
992                    throws com.liferay.portal.NoSuchLayoutException,
993                            com.liferay.portal.kernel.exception.SystemException {
994                    return getPersistence().removeByIconImageId(iconImageId);
995            }
996    
997            /**
998            * Returns the number of layouts where iconImageId = &#63;.
999            *
1000            * @param iconImageId the icon image ID
1001            * @return the number of matching layouts
1002            * @throws SystemException if a system exception occurred
1003            */
1004            public static int countByIconImageId(long iconImageId)
1005                    throws com.liferay.portal.kernel.exception.SystemException {
1006                    return getPersistence().countByIconImageId(iconImageId);
1007            }
1008    
1009            /**
1010            * Returns all the layouts where layoutPrototypeUuid = &#63;.
1011            *
1012            * @param layoutPrototypeUuid the layout prototype uuid
1013            * @return the matching layouts
1014            * @throws SystemException if a system exception occurred
1015            */
1016            public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid(
1017                    java.lang.String layoutPrototypeUuid)
1018                    throws com.liferay.portal.kernel.exception.SystemException {
1019                    return getPersistence().findByLayoutPrototypeUuid(layoutPrototypeUuid);
1020            }
1021    
1022            /**
1023            * Returns a range of all the layouts where layoutPrototypeUuid = &#63;.
1024            *
1025            * <p>
1026            * 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.
1027            * </p>
1028            *
1029            * @param layoutPrototypeUuid the layout prototype uuid
1030            * @param start the lower bound of the range of layouts
1031            * @param end the upper bound of the range of layouts (not inclusive)
1032            * @return the range of matching layouts
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid(
1036                    java.lang.String layoutPrototypeUuid, int start, int end)
1037                    throws com.liferay.portal.kernel.exception.SystemException {
1038                    return getPersistence()
1039                                       .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end);
1040            }
1041    
1042            /**
1043            * Returns an ordered range of all the layouts where layoutPrototypeUuid = &#63;.
1044            *
1045            * <p>
1046            * 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.
1047            * </p>
1048            *
1049            * @param layoutPrototypeUuid the layout prototype uuid
1050            * @param start the lower bound of the range of layouts
1051            * @param end the upper bound of the range of layouts (not inclusive)
1052            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1053            * @return the ordered range of matching layouts
1054            * @throws SystemException if a system exception occurred
1055            */
1056            public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid(
1057                    java.lang.String layoutPrototypeUuid, int start, int end,
1058                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1059                    throws com.liferay.portal.kernel.exception.SystemException {
1060                    return getPersistence()
1061                                       .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end,
1062                            orderByComparator);
1063            }
1064    
1065            /**
1066            * Returns the first layout in the ordered set where layoutPrototypeUuid = &#63;.
1067            *
1068            * @param layoutPrototypeUuid the layout prototype uuid
1069            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1070            * @return the first matching layout
1071            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1072            * @throws SystemException if a system exception occurred
1073            */
1074            public static com.liferay.portal.model.Layout findByLayoutPrototypeUuid_First(
1075                    java.lang.String layoutPrototypeUuid,
1076                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1077                    throws com.liferay.portal.NoSuchLayoutException,
1078                            com.liferay.portal.kernel.exception.SystemException {
1079                    return getPersistence()
1080                                       .findByLayoutPrototypeUuid_First(layoutPrototypeUuid,
1081                            orderByComparator);
1082            }
1083    
1084            /**
1085            * Returns the first layout in the ordered set where layoutPrototypeUuid = &#63;.
1086            *
1087            * @param layoutPrototypeUuid the layout prototype uuid
1088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1089            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1090            * @throws SystemException if a system exception occurred
1091            */
1092            public static com.liferay.portal.model.Layout fetchByLayoutPrototypeUuid_First(
1093                    java.lang.String layoutPrototypeUuid,
1094                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1095                    throws com.liferay.portal.kernel.exception.SystemException {
1096                    return getPersistence()
1097                                       .fetchByLayoutPrototypeUuid_First(layoutPrototypeUuid,
1098                            orderByComparator);
1099            }
1100    
1101            /**
1102            * Returns the last layout in the ordered set where layoutPrototypeUuid = &#63;.
1103            *
1104            * @param layoutPrototypeUuid the layout prototype uuid
1105            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1106            * @return the last matching layout
1107            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1108            * @throws SystemException if a system exception occurred
1109            */
1110            public static com.liferay.portal.model.Layout findByLayoutPrototypeUuid_Last(
1111                    java.lang.String layoutPrototypeUuid,
1112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1113                    throws com.liferay.portal.NoSuchLayoutException,
1114                            com.liferay.portal.kernel.exception.SystemException {
1115                    return getPersistence()
1116                                       .findByLayoutPrototypeUuid_Last(layoutPrototypeUuid,
1117                            orderByComparator);
1118            }
1119    
1120            /**
1121            * Returns the last layout in the ordered set where layoutPrototypeUuid = &#63;.
1122            *
1123            * @param layoutPrototypeUuid the layout prototype uuid
1124            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1125            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1126            * @throws SystemException if a system exception occurred
1127            */
1128            public static com.liferay.portal.model.Layout fetchByLayoutPrototypeUuid_Last(
1129                    java.lang.String layoutPrototypeUuid,
1130                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1131                    throws com.liferay.portal.kernel.exception.SystemException {
1132                    return getPersistence()
1133                                       .fetchByLayoutPrototypeUuid_Last(layoutPrototypeUuid,
1134                            orderByComparator);
1135            }
1136    
1137            /**
1138            * Returns the layouts before and after the current layout in the ordered set where layoutPrototypeUuid = &#63;.
1139            *
1140            * @param plid the primary key of the current layout
1141            * @param layoutPrototypeUuid the layout prototype uuid
1142            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1143            * @return the previous, current, and next layout
1144            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1145            * @throws SystemException if a system exception occurred
1146            */
1147            public static com.liferay.portal.model.Layout[] findByLayoutPrototypeUuid_PrevAndNext(
1148                    long plid, java.lang.String layoutPrototypeUuid,
1149                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1150                    throws com.liferay.portal.NoSuchLayoutException,
1151                            com.liferay.portal.kernel.exception.SystemException {
1152                    return getPersistence()
1153                                       .findByLayoutPrototypeUuid_PrevAndNext(plid,
1154                            layoutPrototypeUuid, orderByComparator);
1155            }
1156    
1157            /**
1158            * Removes all the layouts where layoutPrototypeUuid = &#63; from the database.
1159            *
1160            * @param layoutPrototypeUuid the layout prototype uuid
1161            * @throws SystemException if a system exception occurred
1162            */
1163            public static void removeByLayoutPrototypeUuid(
1164                    java.lang.String layoutPrototypeUuid)
1165                    throws com.liferay.portal.kernel.exception.SystemException {
1166                    getPersistence().removeByLayoutPrototypeUuid(layoutPrototypeUuid);
1167            }
1168    
1169            /**
1170            * Returns the number of layouts where layoutPrototypeUuid = &#63;.
1171            *
1172            * @param layoutPrototypeUuid the layout prototype uuid
1173            * @return the number of matching layouts
1174            * @throws SystemException if a system exception occurred
1175            */
1176            public static int countByLayoutPrototypeUuid(
1177                    java.lang.String layoutPrototypeUuid)
1178                    throws com.liferay.portal.kernel.exception.SystemException {
1179                    return getPersistence().countByLayoutPrototypeUuid(layoutPrototypeUuid);
1180            }
1181    
1182            /**
1183            * Returns all the layouts where sourcePrototypeLayoutUuid = &#63;.
1184            *
1185            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1186            * @return the matching layouts
1187            * @throws SystemException if a system exception occurred
1188            */
1189            public static java.util.List<com.liferay.portal.model.Layout> findBySourcePrototypeLayoutUuid(
1190                    java.lang.String sourcePrototypeLayoutUuid)
1191                    throws com.liferay.portal.kernel.exception.SystemException {
1192                    return getPersistence()
1193                                       .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid);
1194            }
1195    
1196            /**
1197            * Returns a range of all the layouts where sourcePrototypeLayoutUuid = &#63;.
1198            *
1199            * <p>
1200            * 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.
1201            * </p>
1202            *
1203            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1204            * @param start the lower bound of the range of layouts
1205            * @param end the upper bound of the range of layouts (not inclusive)
1206            * @return the range of matching layouts
1207            * @throws SystemException if a system exception occurred
1208            */
1209            public static java.util.List<com.liferay.portal.model.Layout> findBySourcePrototypeLayoutUuid(
1210                    java.lang.String sourcePrototypeLayoutUuid, int start, int end)
1211                    throws com.liferay.portal.kernel.exception.SystemException {
1212                    return getPersistence()
1213                                       .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid,
1214                            start, end);
1215            }
1216    
1217            /**
1218            * Returns an ordered range of all the layouts where sourcePrototypeLayoutUuid = &#63;.
1219            *
1220            * <p>
1221            * 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.
1222            * </p>
1223            *
1224            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1225            * @param start the lower bound of the range of layouts
1226            * @param end the upper bound of the range of layouts (not inclusive)
1227            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1228            * @return the ordered range of matching layouts
1229            * @throws SystemException if a system exception occurred
1230            */
1231            public static java.util.List<com.liferay.portal.model.Layout> findBySourcePrototypeLayoutUuid(
1232                    java.lang.String sourcePrototypeLayoutUuid, int start, int end,
1233                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1234                    throws com.liferay.portal.kernel.exception.SystemException {
1235                    return getPersistence()
1236                                       .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid,
1237                            start, end, orderByComparator);
1238            }
1239    
1240            /**
1241            * Returns the first layout in the ordered set where sourcePrototypeLayoutUuid = &#63;.
1242            *
1243            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1244            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1245            * @return the first matching layout
1246            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1247            * @throws SystemException if a system exception occurred
1248            */
1249            public static com.liferay.portal.model.Layout findBySourcePrototypeLayoutUuid_First(
1250                    java.lang.String sourcePrototypeLayoutUuid,
1251                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1252                    throws com.liferay.portal.NoSuchLayoutException,
1253                            com.liferay.portal.kernel.exception.SystemException {
1254                    return getPersistence()
1255                                       .findBySourcePrototypeLayoutUuid_First(sourcePrototypeLayoutUuid,
1256                            orderByComparator);
1257            }
1258    
1259            /**
1260            * Returns the first layout in the ordered set where sourcePrototypeLayoutUuid = &#63;.
1261            *
1262            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1263            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1264            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1265            * @throws SystemException if a system exception occurred
1266            */
1267            public static com.liferay.portal.model.Layout fetchBySourcePrototypeLayoutUuid_First(
1268                    java.lang.String sourcePrototypeLayoutUuid,
1269                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1270                    throws com.liferay.portal.kernel.exception.SystemException {
1271                    return getPersistence()
1272                                       .fetchBySourcePrototypeLayoutUuid_First(sourcePrototypeLayoutUuid,
1273                            orderByComparator);
1274            }
1275    
1276            /**
1277            * Returns the last layout in the ordered set where sourcePrototypeLayoutUuid = &#63;.
1278            *
1279            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1281            * @return the last matching layout
1282            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1283            * @throws SystemException if a system exception occurred
1284            */
1285            public static com.liferay.portal.model.Layout findBySourcePrototypeLayoutUuid_Last(
1286                    java.lang.String sourcePrototypeLayoutUuid,
1287                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1288                    throws com.liferay.portal.NoSuchLayoutException,
1289                            com.liferay.portal.kernel.exception.SystemException {
1290                    return getPersistence()
1291                                       .findBySourcePrototypeLayoutUuid_Last(sourcePrototypeLayoutUuid,
1292                            orderByComparator);
1293            }
1294    
1295            /**
1296            * Returns the last layout in the ordered set where sourcePrototypeLayoutUuid = &#63;.
1297            *
1298            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1300            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1301            * @throws SystemException if a system exception occurred
1302            */
1303            public static com.liferay.portal.model.Layout fetchBySourcePrototypeLayoutUuid_Last(
1304                    java.lang.String sourcePrototypeLayoutUuid,
1305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1306                    throws com.liferay.portal.kernel.exception.SystemException {
1307                    return getPersistence()
1308                                       .fetchBySourcePrototypeLayoutUuid_Last(sourcePrototypeLayoutUuid,
1309                            orderByComparator);
1310            }
1311    
1312            /**
1313            * Returns the layouts before and after the current layout in the ordered set where sourcePrototypeLayoutUuid = &#63;.
1314            *
1315            * @param plid the primary key of the current layout
1316            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the previous, current, and next layout
1319            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1320            * @throws SystemException if a system exception occurred
1321            */
1322            public static com.liferay.portal.model.Layout[] findBySourcePrototypeLayoutUuid_PrevAndNext(
1323                    long plid, java.lang.String sourcePrototypeLayoutUuid,
1324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1325                    throws com.liferay.portal.NoSuchLayoutException,
1326                            com.liferay.portal.kernel.exception.SystemException {
1327                    return getPersistence()
1328                                       .findBySourcePrototypeLayoutUuid_PrevAndNext(plid,
1329                            sourcePrototypeLayoutUuid, orderByComparator);
1330            }
1331    
1332            /**
1333            * Removes all the layouts where sourcePrototypeLayoutUuid = &#63; from the database.
1334            *
1335            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1336            * @throws SystemException if a system exception occurred
1337            */
1338            public static void removeBySourcePrototypeLayoutUuid(
1339                    java.lang.String sourcePrototypeLayoutUuid)
1340                    throws com.liferay.portal.kernel.exception.SystemException {
1341                    getPersistence()
1342                            .removeBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid);
1343            }
1344    
1345            /**
1346            * Returns the number of layouts where sourcePrototypeLayoutUuid = &#63;.
1347            *
1348            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1349            * @return the number of matching layouts
1350            * @throws SystemException if a system exception occurred
1351            */
1352            public static int countBySourcePrototypeLayoutUuid(
1353                    java.lang.String sourcePrototypeLayoutUuid)
1354                    throws com.liferay.portal.kernel.exception.SystemException {
1355                    return getPersistence()
1356                                       .countBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid);
1357            }
1358    
1359            /**
1360            * Returns all the layouts where groupId = &#63; and privateLayout = &#63;.
1361            *
1362            * @param groupId the group ID
1363            * @param privateLayout the private layout
1364            * @return the matching layouts
1365            * @throws SystemException if a system exception occurred
1366            */
1367            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
1368                    long groupId, boolean privateLayout)
1369                    throws com.liferay.portal.kernel.exception.SystemException {
1370                    return getPersistence().findByG_P(groupId, privateLayout);
1371            }
1372    
1373            /**
1374            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63;.
1375            *
1376            * <p>
1377            * 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.
1378            * </p>
1379            *
1380            * @param groupId the group ID
1381            * @param privateLayout the private layout
1382            * @param start the lower bound of the range of layouts
1383            * @param end the upper bound of the range of layouts (not inclusive)
1384            * @return the range of matching layouts
1385            * @throws SystemException if a system exception occurred
1386            */
1387            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
1388                    long groupId, boolean privateLayout, int start, int end)
1389                    throws com.liferay.portal.kernel.exception.SystemException {
1390                    return getPersistence().findByG_P(groupId, privateLayout, start, end);
1391            }
1392    
1393            /**
1394            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63;.
1395            *
1396            * <p>
1397            * 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.
1398            * </p>
1399            *
1400            * @param groupId the group ID
1401            * @param privateLayout the private layout
1402            * @param start the lower bound of the range of layouts
1403            * @param end the upper bound of the range of layouts (not inclusive)
1404            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1405            * @return the ordered range of matching layouts
1406            * @throws SystemException if a system exception occurred
1407            */
1408            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
1409                    long groupId, boolean privateLayout, int start, int end,
1410                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1411                    throws com.liferay.portal.kernel.exception.SystemException {
1412                    return getPersistence()
1413                                       .findByG_P(groupId, privateLayout, start, end,
1414                            orderByComparator);
1415            }
1416    
1417            /**
1418            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1419            *
1420            * @param groupId the group ID
1421            * @param privateLayout the private layout
1422            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1423            * @return the first matching layout
1424            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1425            * @throws SystemException if a system exception occurred
1426            */
1427            public static com.liferay.portal.model.Layout findByG_P_First(
1428                    long groupId, boolean privateLayout,
1429                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1430                    throws com.liferay.portal.NoSuchLayoutException,
1431                            com.liferay.portal.kernel.exception.SystemException {
1432                    return getPersistence()
1433                                       .findByG_P_First(groupId, privateLayout, orderByComparator);
1434            }
1435    
1436            /**
1437            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1438            *
1439            * @param groupId the group ID
1440            * @param privateLayout the private layout
1441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1442            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1443            * @throws SystemException if a system exception occurred
1444            */
1445            public static com.liferay.portal.model.Layout fetchByG_P_First(
1446                    long groupId, boolean privateLayout,
1447                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1448                    throws com.liferay.portal.kernel.exception.SystemException {
1449                    return getPersistence()
1450                                       .fetchByG_P_First(groupId, privateLayout, orderByComparator);
1451            }
1452    
1453            /**
1454            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1455            *
1456            * @param groupId the group ID
1457            * @param privateLayout the private layout
1458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1459            * @return the last matching layout
1460            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1461            * @throws SystemException if a system exception occurred
1462            */
1463            public static com.liferay.portal.model.Layout findByG_P_Last(long groupId,
1464                    boolean privateLayout,
1465                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1466                    throws com.liferay.portal.NoSuchLayoutException,
1467                            com.liferay.portal.kernel.exception.SystemException {
1468                    return getPersistence()
1469                                       .findByG_P_Last(groupId, privateLayout, orderByComparator);
1470            }
1471    
1472            /**
1473            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1474            *
1475            * @param groupId the group ID
1476            * @param privateLayout the private layout
1477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1478            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1479            * @throws SystemException if a system exception occurred
1480            */
1481            public static com.liferay.portal.model.Layout fetchByG_P_Last(
1482                    long groupId, boolean privateLayout,
1483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1484                    throws com.liferay.portal.kernel.exception.SystemException {
1485                    return getPersistence()
1486                                       .fetchByG_P_Last(groupId, privateLayout, orderByComparator);
1487            }
1488    
1489            /**
1490            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1491            *
1492            * @param plid the primary key of the current layout
1493            * @param groupId the group ID
1494            * @param privateLayout the private layout
1495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1496            * @return the previous, current, and next layout
1497            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1498            * @throws SystemException if a system exception occurred
1499            */
1500            public static com.liferay.portal.model.Layout[] findByG_P_PrevAndNext(
1501                    long plid, long groupId, boolean privateLayout,
1502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1503                    throws com.liferay.portal.NoSuchLayoutException,
1504                            com.liferay.portal.kernel.exception.SystemException {
1505                    return getPersistence()
1506                                       .findByG_P_PrevAndNext(plid, groupId, privateLayout,
1507                            orderByComparator);
1508            }
1509    
1510            /**
1511            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
1512            *
1513            * @param groupId the group ID
1514            * @param privateLayout the private layout
1515            * @return the matching layouts that the user has permission to view
1516            * @throws SystemException if a system exception occurred
1517            */
1518            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
1519                    long groupId, boolean privateLayout)
1520                    throws com.liferay.portal.kernel.exception.SystemException {
1521                    return getPersistence().filterFindByG_P(groupId, privateLayout);
1522            }
1523    
1524            /**
1525            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
1526            *
1527            * <p>
1528            * 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.
1529            * </p>
1530            *
1531            * @param groupId the group ID
1532            * @param privateLayout the private layout
1533            * @param start the lower bound of the range of layouts
1534            * @param end the upper bound of the range of layouts (not inclusive)
1535            * @return the range of matching layouts that the user has permission to view
1536            * @throws SystemException if a system exception occurred
1537            */
1538            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
1539                    long groupId, boolean privateLayout, int start, int end)
1540                    throws com.liferay.portal.kernel.exception.SystemException {
1541                    return getPersistence()
1542                                       .filterFindByG_P(groupId, privateLayout, start, end);
1543            }
1544    
1545            /**
1546            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63;.
1547            *
1548            * <p>
1549            * 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.
1550            * </p>
1551            *
1552            * @param groupId the group ID
1553            * @param privateLayout the private layout
1554            * @param start the lower bound of the range of layouts
1555            * @param end the upper bound of the range of layouts (not inclusive)
1556            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1557            * @return the ordered range of matching layouts that the user has permission to view
1558            * @throws SystemException if a system exception occurred
1559            */
1560            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
1561                    long groupId, boolean privateLayout, int start, int end,
1562                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1563                    throws com.liferay.portal.kernel.exception.SystemException {
1564                    return getPersistence()
1565                                       .filterFindByG_P(groupId, privateLayout, start, end,
1566                            orderByComparator);
1567            }
1568    
1569            /**
1570            * 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;.
1571            *
1572            * @param plid the primary key of the current layout
1573            * @param groupId the group ID
1574            * @param privateLayout the private layout
1575            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1576            * @return the previous, current, and next layout
1577            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1578            * @throws SystemException if a system exception occurred
1579            */
1580            public static com.liferay.portal.model.Layout[] filterFindByG_P_PrevAndNext(
1581                    long plid, long groupId, boolean privateLayout,
1582                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1583                    throws com.liferay.portal.NoSuchLayoutException,
1584                            com.liferay.portal.kernel.exception.SystemException {
1585                    return getPersistence()
1586                                       .filterFindByG_P_PrevAndNext(plid, groupId, privateLayout,
1587                            orderByComparator);
1588            }
1589    
1590            /**
1591            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; from the database.
1592            *
1593            * @param groupId the group ID
1594            * @param privateLayout the private layout
1595            * @throws SystemException if a system exception occurred
1596            */
1597            public static void removeByG_P(long groupId, boolean privateLayout)
1598                    throws com.liferay.portal.kernel.exception.SystemException {
1599                    getPersistence().removeByG_P(groupId, privateLayout);
1600            }
1601    
1602            /**
1603            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63;.
1604            *
1605            * @param groupId the group ID
1606            * @param privateLayout the private layout
1607            * @return the number of matching layouts
1608            * @throws SystemException if a system exception occurred
1609            */
1610            public static int countByG_P(long groupId, boolean privateLayout)
1611                    throws com.liferay.portal.kernel.exception.SystemException {
1612                    return getPersistence().countByG_P(groupId, privateLayout);
1613            }
1614    
1615            /**
1616            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
1617            *
1618            * @param groupId the group ID
1619            * @param privateLayout the private layout
1620            * @return the number of matching layouts that the user has permission to view
1621            * @throws SystemException if a system exception occurred
1622            */
1623            public static int filterCountByG_P(long groupId, boolean privateLayout)
1624                    throws com.liferay.portal.kernel.exception.SystemException {
1625                    return getPersistence().filterCountByG_P(groupId, privateLayout);
1626            }
1627    
1628            /**
1629            * Returns all the layouts where companyId = &#63; and layoutPrototypeUuid = &#63;.
1630            *
1631            * @param companyId the company ID
1632            * @param layoutPrototypeUuid the layout prototype uuid
1633            * @return the matching layouts
1634            * @throws SystemException if a system exception occurred
1635            */
1636            public static java.util.List<com.liferay.portal.model.Layout> findByC_L(
1637                    long companyId, java.lang.String layoutPrototypeUuid)
1638                    throws com.liferay.portal.kernel.exception.SystemException {
1639                    return getPersistence().findByC_L(companyId, layoutPrototypeUuid);
1640            }
1641    
1642            /**
1643            * Returns a range of all the layouts where companyId = &#63; and layoutPrototypeUuid = &#63;.
1644            *
1645            * <p>
1646            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
1647            * </p>
1648            *
1649            * @param companyId the company ID
1650            * @param layoutPrototypeUuid the layout prototype uuid
1651            * @param start the lower bound of the range of layouts
1652            * @param end the upper bound of the range of layouts (not inclusive)
1653            * @return the range of matching layouts
1654            * @throws SystemException if a system exception occurred
1655            */
1656            public static java.util.List<com.liferay.portal.model.Layout> findByC_L(
1657                    long companyId, java.lang.String layoutPrototypeUuid, int start, int end)
1658                    throws com.liferay.portal.kernel.exception.SystemException {
1659                    return getPersistence()
1660                                       .findByC_L(companyId, layoutPrototypeUuid, start, end);
1661            }
1662    
1663            /**
1664            * Returns an ordered range of all the layouts where companyId = &#63; and layoutPrototypeUuid = &#63;.
1665            *
1666            * <p>
1667            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.
1668            * </p>
1669            *
1670            * @param companyId the company ID
1671            * @param layoutPrototypeUuid the layout prototype uuid
1672            * @param start the lower bound of the range of layouts
1673            * @param end the upper bound of the range of layouts (not inclusive)
1674            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1675            * @return the ordered range of matching layouts
1676            * @throws SystemException if a system exception occurred
1677            */
1678            public static java.util.List<com.liferay.portal.model.Layout> findByC_L(
1679                    long companyId, java.lang.String layoutPrototypeUuid, int start,
1680                    int end,
1681                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1682                    throws com.liferay.portal.kernel.exception.SystemException {
1683                    return getPersistence()
1684                                       .findByC_L(companyId, layoutPrototypeUuid, start, end,
1685                            orderByComparator);
1686            }
1687    
1688            /**
1689            * Returns the first layout in the ordered set where companyId = &#63; and layoutPrototypeUuid = &#63;.
1690            *
1691            * @param companyId the company ID
1692            * @param layoutPrototypeUuid the layout prototype uuid
1693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1694            * @return the first matching layout
1695            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1696            * @throws SystemException if a system exception occurred
1697            */
1698            public static com.liferay.portal.model.Layout findByC_L_First(
1699                    long companyId, java.lang.String layoutPrototypeUuid,
1700                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1701                    throws com.liferay.portal.NoSuchLayoutException,
1702                            com.liferay.portal.kernel.exception.SystemException {
1703                    return getPersistence()
1704                                       .findByC_L_First(companyId, layoutPrototypeUuid,
1705                            orderByComparator);
1706            }
1707    
1708            /**
1709            * Returns the first layout in the ordered set where companyId = &#63; and layoutPrototypeUuid = &#63;.
1710            *
1711            * @param companyId the company ID
1712            * @param layoutPrototypeUuid the layout prototype uuid
1713            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1714            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1715            * @throws SystemException if a system exception occurred
1716            */
1717            public static com.liferay.portal.model.Layout fetchByC_L_First(
1718                    long companyId, java.lang.String layoutPrototypeUuid,
1719                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1720                    throws com.liferay.portal.kernel.exception.SystemException {
1721                    return getPersistence()
1722                                       .fetchByC_L_First(companyId, layoutPrototypeUuid,
1723                            orderByComparator);
1724            }
1725    
1726            /**
1727            * Returns the last layout in the ordered set where companyId = &#63; and layoutPrototypeUuid = &#63;.
1728            *
1729            * @param companyId the company ID
1730            * @param layoutPrototypeUuid the layout prototype uuid
1731            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1732            * @return the last matching layout
1733            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1734            * @throws SystemException if a system exception occurred
1735            */
1736            public static com.liferay.portal.model.Layout findByC_L_Last(
1737                    long companyId, java.lang.String layoutPrototypeUuid,
1738                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1739                    throws com.liferay.portal.NoSuchLayoutException,
1740                            com.liferay.portal.kernel.exception.SystemException {
1741                    return getPersistence()
1742                                       .findByC_L_Last(companyId, layoutPrototypeUuid,
1743                            orderByComparator);
1744            }
1745    
1746            /**
1747            * Returns the last layout in the ordered set where companyId = &#63; and layoutPrototypeUuid = &#63;.
1748            *
1749            * @param companyId the company ID
1750            * @param layoutPrototypeUuid the layout prototype uuid
1751            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1752            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1753            * @throws SystemException if a system exception occurred
1754            */
1755            public static com.liferay.portal.model.Layout fetchByC_L_Last(
1756                    long companyId, java.lang.String layoutPrototypeUuid,
1757                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1758                    throws com.liferay.portal.kernel.exception.SystemException {
1759                    return getPersistence()
1760                                       .fetchByC_L_Last(companyId, layoutPrototypeUuid,
1761                            orderByComparator);
1762            }
1763    
1764            /**
1765            * Returns the layouts before and after the current layout in the ordered set where companyId = &#63; and layoutPrototypeUuid = &#63;.
1766            *
1767            * @param plid the primary key of the current layout
1768            * @param companyId the company ID
1769            * @param layoutPrototypeUuid the layout prototype uuid
1770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1771            * @return the previous, current, and next layout
1772            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1773            * @throws SystemException if a system exception occurred
1774            */
1775            public static com.liferay.portal.model.Layout[] findByC_L_PrevAndNext(
1776                    long plid, long companyId, java.lang.String layoutPrototypeUuid,
1777                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1778                    throws com.liferay.portal.NoSuchLayoutException,
1779                            com.liferay.portal.kernel.exception.SystemException {
1780                    return getPersistence()
1781                                       .findByC_L_PrevAndNext(plid, companyId, layoutPrototypeUuid,
1782                            orderByComparator);
1783            }
1784    
1785            /**
1786            * Removes all the layouts where companyId = &#63; and layoutPrototypeUuid = &#63; from the database.
1787            *
1788            * @param companyId the company ID
1789            * @param layoutPrototypeUuid the layout prototype uuid
1790            * @throws SystemException if a system exception occurred
1791            */
1792            public static void removeByC_L(long companyId,
1793                    java.lang.String layoutPrototypeUuid)
1794                    throws com.liferay.portal.kernel.exception.SystemException {
1795                    getPersistence().removeByC_L(companyId, layoutPrototypeUuid);
1796            }
1797    
1798            /**
1799            * Returns the number of layouts where companyId = &#63; and layoutPrototypeUuid = &#63;.
1800            *
1801            * @param companyId the company ID
1802            * @param layoutPrototypeUuid the layout prototype uuid
1803            * @return the number of matching layouts
1804            * @throws SystemException if a system exception occurred
1805            */
1806            public static int countByC_L(long companyId,
1807                    java.lang.String layoutPrototypeUuid)
1808                    throws com.liferay.portal.kernel.exception.SystemException {
1809                    return getPersistence().countByC_L(companyId, layoutPrototypeUuid);
1810            }
1811    
1812            /**
1813            * Returns the layout where privateLayout = &#63; and iconImageId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
1814            *
1815            * @param privateLayout the private layout
1816            * @param iconImageId the icon image ID
1817            * @return the matching layout
1818            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1819            * @throws SystemException if a system exception occurred
1820            */
1821            public static com.liferay.portal.model.Layout findByP_I(
1822                    boolean privateLayout, long iconImageId)
1823                    throws com.liferay.portal.NoSuchLayoutException,
1824                            com.liferay.portal.kernel.exception.SystemException {
1825                    return getPersistence().findByP_I(privateLayout, iconImageId);
1826            }
1827    
1828            /**
1829            * Returns the layout where privateLayout = &#63; and iconImageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1830            *
1831            * @param privateLayout the private layout
1832            * @param iconImageId the icon image ID
1833            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1834            * @throws SystemException if a system exception occurred
1835            */
1836            public static com.liferay.portal.model.Layout fetchByP_I(
1837                    boolean privateLayout, long iconImageId)
1838                    throws com.liferay.portal.kernel.exception.SystemException {
1839                    return getPersistence().fetchByP_I(privateLayout, iconImageId);
1840            }
1841    
1842            /**
1843            * Returns the layout where privateLayout = &#63; and iconImageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1844            *
1845            * @param privateLayout the private layout
1846            * @param iconImageId the icon image ID
1847            * @param retrieveFromCache whether to use the finder cache
1848            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1849            * @throws SystemException if a system exception occurred
1850            */
1851            public static com.liferay.portal.model.Layout fetchByP_I(
1852                    boolean privateLayout, long iconImageId, boolean retrieveFromCache)
1853                    throws com.liferay.portal.kernel.exception.SystemException {
1854                    return getPersistence()
1855                                       .fetchByP_I(privateLayout, iconImageId, retrieveFromCache);
1856            }
1857    
1858            /**
1859            * Removes the layout where privateLayout = &#63; and iconImageId = &#63; from the database.
1860            *
1861            * @param privateLayout the private layout
1862            * @param iconImageId the icon image ID
1863            * @return the layout that was removed
1864            * @throws SystemException if a system exception occurred
1865            */
1866            public static com.liferay.portal.model.Layout removeByP_I(
1867                    boolean privateLayout, long iconImageId)
1868                    throws com.liferay.portal.NoSuchLayoutException,
1869                            com.liferay.portal.kernel.exception.SystemException {
1870                    return getPersistence().removeByP_I(privateLayout, iconImageId);
1871            }
1872    
1873            /**
1874            * Returns the number of layouts where privateLayout = &#63; and iconImageId = &#63;.
1875            *
1876            * @param privateLayout the private layout
1877            * @param iconImageId the icon image ID
1878            * @return the number of matching layouts
1879            * @throws SystemException if a system exception occurred
1880            */
1881            public static int countByP_I(boolean privateLayout, long iconImageId)
1882                    throws com.liferay.portal.kernel.exception.SystemException {
1883                    return getPersistence().countByP_I(privateLayout, iconImageId);
1884            }
1885    
1886            /**
1887            * 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.
1888            *
1889            * @param groupId the group ID
1890            * @param privateLayout the private layout
1891            * @param layoutId the layout ID
1892            * @return the matching layout
1893            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1894            * @throws SystemException if a system exception occurred
1895            */
1896            public static com.liferay.portal.model.Layout findByG_P_L(long groupId,
1897                    boolean privateLayout, long layoutId)
1898                    throws com.liferay.portal.NoSuchLayoutException,
1899                            com.liferay.portal.kernel.exception.SystemException {
1900                    return getPersistence().findByG_P_L(groupId, privateLayout, layoutId);
1901            }
1902    
1903            /**
1904            * 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.
1905            *
1906            * @param groupId the group ID
1907            * @param privateLayout the private layout
1908            * @param layoutId the layout ID
1909            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1910            * @throws SystemException if a system exception occurred
1911            */
1912            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1913                    boolean privateLayout, long layoutId)
1914                    throws com.liferay.portal.kernel.exception.SystemException {
1915                    return getPersistence().fetchByG_P_L(groupId, privateLayout, layoutId);
1916            }
1917    
1918            /**
1919            * 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.
1920            *
1921            * @param groupId the group ID
1922            * @param privateLayout the private layout
1923            * @param layoutId the layout ID
1924            * @param retrieveFromCache whether to use the finder cache
1925            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1926            * @throws SystemException if a system exception occurred
1927            */
1928            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1929                    boolean privateLayout, long layoutId, boolean retrieveFromCache)
1930                    throws com.liferay.portal.kernel.exception.SystemException {
1931                    return getPersistence()
1932                                       .fetchByG_P_L(groupId, privateLayout, layoutId,
1933                            retrieveFromCache);
1934            }
1935    
1936            /**
1937            * Removes the layout where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; from the database.
1938            *
1939            * @param groupId the group ID
1940            * @param privateLayout the private layout
1941            * @param layoutId the layout ID
1942            * @return the layout that was removed
1943            * @throws SystemException if a system exception occurred
1944            */
1945            public static com.liferay.portal.model.Layout removeByG_P_L(long groupId,
1946                    boolean privateLayout, long layoutId)
1947                    throws com.liferay.portal.NoSuchLayoutException,
1948                            com.liferay.portal.kernel.exception.SystemException {
1949                    return getPersistence().removeByG_P_L(groupId, privateLayout, layoutId);
1950            }
1951    
1952            /**
1953            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
1954            *
1955            * @param groupId the group ID
1956            * @param privateLayout the private layout
1957            * @param layoutId the layout ID
1958            * @return the number of matching layouts
1959            * @throws SystemException if a system exception occurred
1960            */
1961            public static int countByG_P_L(long groupId, boolean privateLayout,
1962                    long layoutId)
1963                    throws com.liferay.portal.kernel.exception.SystemException {
1964                    return getPersistence().countByG_P_L(groupId, privateLayout, layoutId);
1965            }
1966    
1967            /**
1968            * 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.
1969            *
1970            * @param groupId the group ID
1971            * @param privateLayout the private layout
1972            * @param friendlyURL the friendly u r l
1973            * @return the matching layout
1974            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1975            * @throws SystemException if a system exception occurred
1976            */
1977            public static com.liferay.portal.model.Layout findByG_P_F(long groupId,
1978                    boolean privateLayout, java.lang.String friendlyURL)
1979                    throws com.liferay.portal.NoSuchLayoutException,
1980                            com.liferay.portal.kernel.exception.SystemException {
1981                    return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL);
1982            }
1983    
1984            /**
1985            * 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.
1986            *
1987            * @param groupId the group ID
1988            * @param privateLayout the private layout
1989            * @param friendlyURL the friendly u r l
1990            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1991            * @throws SystemException if a system exception occurred
1992            */
1993            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1994                    boolean privateLayout, java.lang.String friendlyURL)
1995                    throws com.liferay.portal.kernel.exception.SystemException {
1996                    return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL);
1997            }
1998    
1999            /**
2000            * 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.
2001            *
2002            * @param groupId the group ID
2003            * @param privateLayout the private layout
2004            * @param friendlyURL the friendly u r l
2005            * @param retrieveFromCache whether to use the finder cache
2006            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2007            * @throws SystemException if a system exception occurred
2008            */
2009            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
2010                    boolean privateLayout, java.lang.String friendlyURL,
2011                    boolean retrieveFromCache)
2012                    throws com.liferay.portal.kernel.exception.SystemException {
2013                    return getPersistence()
2014                                       .fetchByG_P_F(groupId, privateLayout, friendlyURL,
2015                            retrieveFromCache);
2016            }
2017    
2018            /**
2019            * Removes the layout where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; from the database.
2020            *
2021            * @param groupId the group ID
2022            * @param privateLayout the private layout
2023            * @param friendlyURL the friendly u r l
2024            * @return the layout that was removed
2025            * @throws SystemException if a system exception occurred
2026            */
2027            public static com.liferay.portal.model.Layout removeByG_P_F(long groupId,
2028                    boolean privateLayout, java.lang.String friendlyURL)
2029                    throws com.liferay.portal.NoSuchLayoutException,
2030                            com.liferay.portal.kernel.exception.SystemException {
2031                    return getPersistence()
2032                                       .removeByG_P_F(groupId, privateLayout, friendlyURL);
2033            }
2034    
2035            /**
2036            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
2037            *
2038            * @param groupId the group ID
2039            * @param privateLayout the private layout
2040            * @param friendlyURL the friendly u r l
2041            * @return the number of matching layouts
2042            * @throws SystemException if a system exception occurred
2043            */
2044            public static int countByG_P_F(long groupId, boolean privateLayout,
2045                    java.lang.String friendlyURL)
2046                    throws com.liferay.portal.kernel.exception.SystemException {
2047                    return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL);
2048            }
2049    
2050            /**
2051            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2052            *
2053            * @param groupId the group ID
2054            * @param privateLayout the private layout
2055            * @param parentLayoutId the parent layout ID
2056            * @return the matching layouts
2057            * @throws SystemException if a system exception occurred
2058            */
2059            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
2060                    long groupId, boolean privateLayout, long parentLayoutId)
2061                    throws com.liferay.portal.kernel.exception.SystemException {
2062                    return getPersistence()
2063                                       .findByG_P_P(groupId, privateLayout, parentLayoutId);
2064            }
2065    
2066            /**
2067            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2068            *
2069            * <p>
2070            * 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.
2071            * </p>
2072            *
2073            * @param groupId the group ID
2074            * @param privateLayout the private layout
2075            * @param parentLayoutId the parent layout ID
2076            * @param start the lower bound of the range of layouts
2077            * @param end the upper bound of the range of layouts (not inclusive)
2078            * @return the range of matching layouts
2079            * @throws SystemException if a system exception occurred
2080            */
2081            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
2082                    long groupId, boolean privateLayout, long parentLayoutId, int start,
2083                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2084                    return getPersistence()
2085                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
2086                            end);
2087            }
2088    
2089            /**
2090            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2091            *
2092            * <p>
2093            * 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.
2094            * </p>
2095            *
2096            * @param groupId the group ID
2097            * @param privateLayout the private layout
2098            * @param parentLayoutId the parent layout ID
2099            * @param start the lower bound of the range of layouts
2100            * @param end the upper bound of the range of layouts (not inclusive)
2101            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2102            * @return the ordered range of matching layouts
2103            * @throws SystemException if a system exception occurred
2104            */
2105            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
2106                    long groupId, boolean privateLayout, long parentLayoutId, int start,
2107                    int end,
2108                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2109                    throws com.liferay.portal.kernel.exception.SystemException {
2110                    return getPersistence()
2111                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
2112                            end, orderByComparator);
2113            }
2114    
2115            /**
2116            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2117            *
2118            * @param groupId the group ID
2119            * @param privateLayout the private layout
2120            * @param parentLayoutId the parent layout ID
2121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2122            * @return the first matching layout
2123            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2124            * @throws SystemException if a system exception occurred
2125            */
2126            public static com.liferay.portal.model.Layout findByG_P_P_First(
2127                    long groupId, boolean privateLayout, long parentLayoutId,
2128                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2129                    throws com.liferay.portal.NoSuchLayoutException,
2130                            com.liferay.portal.kernel.exception.SystemException {
2131                    return getPersistence()
2132                                       .findByG_P_P_First(groupId, privateLayout, parentLayoutId,
2133                            orderByComparator);
2134            }
2135    
2136            /**
2137            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2138            *
2139            * @param groupId the group ID
2140            * @param privateLayout the private layout
2141            * @param parentLayoutId the parent layout ID
2142            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2143            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
2144            * @throws SystemException if a system exception occurred
2145            */
2146            public static com.liferay.portal.model.Layout fetchByG_P_P_First(
2147                    long groupId, boolean privateLayout, long parentLayoutId,
2148                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2149                    throws com.liferay.portal.kernel.exception.SystemException {
2150                    return getPersistence()
2151                                       .fetchByG_P_P_First(groupId, privateLayout, parentLayoutId,
2152                            orderByComparator);
2153            }
2154    
2155            /**
2156            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2157            *
2158            * @param groupId the group ID
2159            * @param privateLayout the private layout
2160            * @param parentLayoutId the parent layout ID
2161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2162            * @return the last matching layout
2163            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2164            * @throws SystemException if a system exception occurred
2165            */
2166            public static com.liferay.portal.model.Layout findByG_P_P_Last(
2167                    long groupId, boolean privateLayout, long parentLayoutId,
2168                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2169                    throws com.liferay.portal.NoSuchLayoutException,
2170                            com.liferay.portal.kernel.exception.SystemException {
2171                    return getPersistence()
2172                                       .findByG_P_P_Last(groupId, privateLayout, parentLayoutId,
2173                            orderByComparator);
2174            }
2175    
2176            /**
2177            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2178            *
2179            * @param groupId the group ID
2180            * @param privateLayout the private layout
2181            * @param parentLayoutId the parent layout ID
2182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2183            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
2184            * @throws SystemException if a system exception occurred
2185            */
2186            public static com.liferay.portal.model.Layout fetchByG_P_P_Last(
2187                    long groupId, boolean privateLayout, long parentLayoutId,
2188                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2189                    throws com.liferay.portal.kernel.exception.SystemException {
2190                    return getPersistence()
2191                                       .fetchByG_P_P_Last(groupId, privateLayout, parentLayoutId,
2192                            orderByComparator);
2193            }
2194    
2195            /**
2196            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2197            *
2198            * @param plid the primary key of the current layout
2199            * @param groupId the group ID
2200            * @param privateLayout the private layout
2201            * @param parentLayoutId the parent layout ID
2202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2203            * @return the previous, current, and next layout
2204            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2205            * @throws SystemException if a system exception occurred
2206            */
2207            public static com.liferay.portal.model.Layout[] findByG_P_P_PrevAndNext(
2208                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2210                    throws com.liferay.portal.NoSuchLayoutException,
2211                            com.liferay.portal.kernel.exception.SystemException {
2212                    return getPersistence()
2213                                       .findByG_P_P_PrevAndNext(plid, groupId, privateLayout,
2214                            parentLayoutId, orderByComparator);
2215            }
2216    
2217            /**
2218            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2219            *
2220            * @param groupId the group ID
2221            * @param privateLayout the private layout
2222            * @param parentLayoutId the parent layout ID
2223            * @return the matching layouts that the user has permission to view
2224            * @throws SystemException if a system exception occurred
2225            */
2226            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
2227                    long groupId, boolean privateLayout, long parentLayoutId)
2228                    throws com.liferay.portal.kernel.exception.SystemException {
2229                    return getPersistence()
2230                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId);
2231            }
2232    
2233            /**
2234            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2235            *
2236            * <p>
2237            * 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.
2238            * </p>
2239            *
2240            * @param groupId the group ID
2241            * @param privateLayout the private layout
2242            * @param parentLayoutId the parent layout ID
2243            * @param start the lower bound of the range of layouts
2244            * @param end the upper bound of the range of layouts (not inclusive)
2245            * @return the range of matching layouts that the user has permission to view
2246            * @throws SystemException if a system exception occurred
2247            */
2248            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
2249                    long groupId, boolean privateLayout, long parentLayoutId, int start,
2250                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2251                    return getPersistence()
2252                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
2253                            start, end);
2254            }
2255    
2256            /**
2257            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2258            *
2259            * <p>
2260            * 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.
2261            * </p>
2262            *
2263            * @param groupId the group ID
2264            * @param privateLayout the private layout
2265            * @param parentLayoutId the parent layout ID
2266            * @param start the lower bound of the range of layouts
2267            * @param end the upper bound of the range of layouts (not inclusive)
2268            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2269            * @return the ordered range of matching layouts that the user has permission to view
2270            * @throws SystemException if a system exception occurred
2271            */
2272            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
2273                    long groupId, boolean privateLayout, long parentLayoutId, int start,
2274                    int end,
2275                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2276                    throws com.liferay.portal.kernel.exception.SystemException {
2277                    return getPersistence()
2278                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
2279                            start, end, orderByComparator);
2280            }
2281    
2282            /**
2283            * 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;.
2284            *
2285            * @param plid the primary key of the current layout
2286            * @param groupId the group ID
2287            * @param privateLayout the private layout
2288            * @param parentLayoutId the parent layout ID
2289            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2290            * @return the previous, current, and next layout
2291            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_PrevAndNext(
2295                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2296                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2297                    throws com.liferay.portal.NoSuchLayoutException,
2298                            com.liferay.portal.kernel.exception.SystemException {
2299                    return getPersistence()
2300                                       .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout,
2301                            parentLayoutId, orderByComparator);
2302            }
2303    
2304            /**
2305            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; from the database.
2306            *
2307            * @param groupId the group ID
2308            * @param privateLayout the private layout
2309            * @param parentLayoutId the parent layout ID
2310            * @throws SystemException if a system exception occurred
2311            */
2312            public static void removeByG_P_P(long groupId, boolean privateLayout,
2313                    long parentLayoutId)
2314                    throws com.liferay.portal.kernel.exception.SystemException {
2315                    getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId);
2316            }
2317    
2318            /**
2319            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2320            *
2321            * @param groupId the group ID
2322            * @param privateLayout the private layout
2323            * @param parentLayoutId the parent layout ID
2324            * @return the number of matching layouts
2325            * @throws SystemException if a system exception occurred
2326            */
2327            public static int countByG_P_P(long groupId, boolean privateLayout,
2328                    long parentLayoutId)
2329                    throws com.liferay.portal.kernel.exception.SystemException {
2330                    return getPersistence()
2331                                       .countByG_P_P(groupId, privateLayout, parentLayoutId);
2332            }
2333    
2334            /**
2335            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2336            *
2337            * @param groupId the group ID
2338            * @param privateLayout the private layout
2339            * @param parentLayoutId the parent layout ID
2340            * @return the number of matching layouts that the user has permission to view
2341            * @throws SystemException if a system exception occurred
2342            */
2343            public static int filterCountByG_P_P(long groupId, boolean privateLayout,
2344                    long parentLayoutId)
2345                    throws com.liferay.portal.kernel.exception.SystemException {
2346                    return getPersistence()
2347                                       .filterCountByG_P_P(groupId, privateLayout, parentLayoutId);
2348            }
2349    
2350            /**
2351            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2352            *
2353            * @param groupId the group ID
2354            * @param privateLayout the private layout
2355            * @param type the type
2356            * @return the matching layouts
2357            * @throws SystemException if a system exception occurred
2358            */
2359            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
2360                    long groupId, boolean privateLayout, java.lang.String type)
2361                    throws com.liferay.portal.kernel.exception.SystemException {
2362                    return getPersistence().findByG_P_T(groupId, privateLayout, type);
2363            }
2364    
2365            /**
2366            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2367            *
2368            * <p>
2369            * 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.
2370            * </p>
2371            *
2372            * @param groupId the group ID
2373            * @param privateLayout the private layout
2374            * @param type the type
2375            * @param start the lower bound of the range of layouts
2376            * @param end the upper bound of the range of layouts (not inclusive)
2377            * @return the range of matching layouts
2378            * @throws SystemException if a system exception occurred
2379            */
2380            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
2381                    long groupId, boolean privateLayout, java.lang.String type, int start,
2382                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2383                    return getPersistence()
2384                                       .findByG_P_T(groupId, privateLayout, type, start, end);
2385            }
2386    
2387            /**
2388            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2389            *
2390            * <p>
2391            * 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.
2392            * </p>
2393            *
2394            * @param groupId the group ID
2395            * @param privateLayout the private layout
2396            * @param type the type
2397            * @param start the lower bound of the range of layouts
2398            * @param end the upper bound of the range of layouts (not inclusive)
2399            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2400            * @return the ordered range of matching layouts
2401            * @throws SystemException if a system exception occurred
2402            */
2403            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
2404                    long groupId, boolean privateLayout, java.lang.String type, int start,
2405                    int end,
2406                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2407                    throws com.liferay.portal.kernel.exception.SystemException {
2408                    return getPersistence()
2409                                       .findByG_P_T(groupId, privateLayout, type, start, end,
2410                            orderByComparator);
2411            }
2412    
2413            /**
2414            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2415            *
2416            * @param groupId the group ID
2417            * @param privateLayout the private layout
2418            * @param type the type
2419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2420            * @return the first matching layout
2421            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2422            * @throws SystemException if a system exception occurred
2423            */
2424            public static com.liferay.portal.model.Layout findByG_P_T_First(
2425                    long groupId, boolean privateLayout, java.lang.String type,
2426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2427                    throws com.liferay.portal.NoSuchLayoutException,
2428                            com.liferay.portal.kernel.exception.SystemException {
2429                    return getPersistence()
2430                                       .findByG_P_T_First(groupId, privateLayout, type,
2431                            orderByComparator);
2432            }
2433    
2434            /**
2435            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2436            *
2437            * @param groupId the group ID
2438            * @param privateLayout the private layout
2439            * @param type the type
2440            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2441            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
2442            * @throws SystemException if a system exception occurred
2443            */
2444            public static com.liferay.portal.model.Layout fetchByG_P_T_First(
2445                    long groupId, boolean privateLayout, java.lang.String type,
2446                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2447                    throws com.liferay.portal.kernel.exception.SystemException {
2448                    return getPersistence()
2449                                       .fetchByG_P_T_First(groupId, privateLayout, type,
2450                            orderByComparator);
2451            }
2452    
2453            /**
2454            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2455            *
2456            * @param groupId the group ID
2457            * @param privateLayout the private layout
2458            * @param type the type
2459            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2460            * @return the last matching layout
2461            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2462            * @throws SystemException if a system exception occurred
2463            */
2464            public static com.liferay.portal.model.Layout findByG_P_T_Last(
2465                    long groupId, boolean privateLayout, java.lang.String type,
2466                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2467                    throws com.liferay.portal.NoSuchLayoutException,
2468                            com.liferay.portal.kernel.exception.SystemException {
2469                    return getPersistence()
2470                                       .findByG_P_T_Last(groupId, privateLayout, type,
2471                            orderByComparator);
2472            }
2473    
2474            /**
2475            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2476            *
2477            * @param groupId the group ID
2478            * @param privateLayout the private layout
2479            * @param type the type
2480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2481            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
2482            * @throws SystemException if a system exception occurred
2483            */
2484            public static com.liferay.portal.model.Layout fetchByG_P_T_Last(
2485                    long groupId, boolean privateLayout, java.lang.String type,
2486                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2487                    throws com.liferay.portal.kernel.exception.SystemException {
2488                    return getPersistence()
2489                                       .fetchByG_P_T_Last(groupId, privateLayout, type,
2490                            orderByComparator);
2491            }
2492    
2493            /**
2494            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2495            *
2496            * @param plid the primary key of the current layout
2497            * @param groupId the group ID
2498            * @param privateLayout the private layout
2499            * @param type the type
2500            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2501            * @return the previous, current, and next layout
2502            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2503            * @throws SystemException if a system exception occurred
2504            */
2505            public static com.liferay.portal.model.Layout[] findByG_P_T_PrevAndNext(
2506                    long plid, long groupId, boolean privateLayout, java.lang.String type,
2507                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2508                    throws com.liferay.portal.NoSuchLayoutException,
2509                            com.liferay.portal.kernel.exception.SystemException {
2510                    return getPersistence()
2511                                       .findByG_P_T_PrevAndNext(plid, groupId, privateLayout, type,
2512                            orderByComparator);
2513            }
2514    
2515            /**
2516            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2517            *
2518            * @param groupId the group ID
2519            * @param privateLayout the private layout
2520            * @param type the type
2521            * @return the matching layouts that the user has permission to view
2522            * @throws SystemException if a system exception occurred
2523            */
2524            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
2525                    long groupId, boolean privateLayout, java.lang.String type)
2526                    throws com.liferay.portal.kernel.exception.SystemException {
2527                    return getPersistence().filterFindByG_P_T(groupId, privateLayout, type);
2528            }
2529    
2530            /**
2531            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2532            *
2533            * <p>
2534            * 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.
2535            * </p>
2536            *
2537            * @param groupId the group ID
2538            * @param privateLayout the private layout
2539            * @param type the type
2540            * @param start the lower bound of the range of layouts
2541            * @param end the upper bound of the range of layouts (not inclusive)
2542            * @return the range of matching layouts that the user has permission to view
2543            * @throws SystemException if a system exception occurred
2544            */
2545            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
2546                    long groupId, boolean privateLayout, java.lang.String type, int start,
2547                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2548                    return getPersistence()
2549                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end);
2550            }
2551    
2552            /**
2553            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2554            *
2555            * <p>
2556            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LayoutModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2557            * </p>
2558            *
2559            * @param groupId the group ID
2560            * @param privateLayout the private layout
2561            * @param type the type
2562            * @param start the lower bound of the range of layouts
2563            * @param end the upper bound of the range of layouts (not inclusive)
2564            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2565            * @return the ordered range of matching layouts that the user has permission to view
2566            * @throws SystemException if a system exception occurred
2567            */
2568            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
2569                    long groupId, boolean privateLayout, java.lang.String type, int start,
2570                    int end,
2571                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2572                    throws com.liferay.portal.kernel.exception.SystemException {
2573                    return getPersistence()
2574                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end,
2575                            orderByComparator);
2576            }
2577    
2578            /**
2579            * 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;.
2580            *
2581            * @param plid the primary key of the current layout
2582            * @param groupId the group ID
2583            * @param privateLayout the private layout
2584            * @param type the type
2585            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2586            * @return the previous, current, and next layout
2587            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2588            * @throws SystemException if a system exception occurred
2589            */
2590            public static com.liferay.portal.model.Layout[] filterFindByG_P_T_PrevAndNext(
2591                    long plid, long groupId, boolean privateLayout, java.lang.String type,
2592                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2593                    throws com.liferay.portal.NoSuchLayoutException,
2594                            com.liferay.portal.kernel.exception.SystemException {
2595                    return getPersistence()
2596                                       .filterFindByG_P_T_PrevAndNext(plid, groupId, privateLayout,
2597                            type, orderByComparator);
2598            }
2599    
2600            /**
2601            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63; from the database.
2602            *
2603            * @param groupId the group ID
2604            * @param privateLayout the private layout
2605            * @param type the type
2606            * @throws SystemException if a system exception occurred
2607            */
2608            public static void removeByG_P_T(long groupId, boolean privateLayout,
2609                    java.lang.String type)
2610                    throws com.liferay.portal.kernel.exception.SystemException {
2611                    getPersistence().removeByG_P_T(groupId, privateLayout, type);
2612            }
2613    
2614            /**
2615            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2616            *
2617            * @param groupId the group ID
2618            * @param privateLayout the private layout
2619            * @param type the type
2620            * @return the number of matching layouts
2621            * @throws SystemException if a system exception occurred
2622            */
2623            public static int countByG_P_T(long groupId, boolean privateLayout,
2624                    java.lang.String type)
2625                    throws com.liferay.portal.kernel.exception.SystemException {
2626                    return getPersistence().countByG_P_T(groupId, privateLayout, type);
2627            }
2628    
2629            /**
2630            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2631            *
2632            * @param groupId the group ID
2633            * @param privateLayout the private layout
2634            * @param type the type
2635            * @return the number of matching layouts that the user has permission to view
2636            * @throws SystemException if a system exception occurred
2637            */
2638            public static int filterCountByG_P_T(long groupId, boolean privateLayout,
2639                    java.lang.String type)
2640                    throws com.liferay.portal.kernel.exception.SystemException {
2641                    return getPersistence().filterCountByG_P_T(groupId, privateLayout, type);
2642            }
2643    
2644            /**
2645            * 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.
2646            *
2647            * @param groupId the group ID
2648            * @param privateLayout the private layout
2649            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2650            * @return the matching layout
2651            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2652            * @throws SystemException if a system exception occurred
2653            */
2654            public static com.liferay.portal.model.Layout findByG_P_SPLU(long groupId,
2655                    boolean privateLayout, java.lang.String sourcePrototypeLayoutUuid)
2656                    throws com.liferay.portal.NoSuchLayoutException,
2657                            com.liferay.portal.kernel.exception.SystemException {
2658                    return getPersistence()
2659                                       .findByG_P_SPLU(groupId, privateLayout,
2660                            sourcePrototypeLayoutUuid);
2661            }
2662    
2663            /**
2664            * 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.
2665            *
2666            * @param groupId the group ID
2667            * @param privateLayout the private layout
2668            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2669            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2670            * @throws SystemException if a system exception occurred
2671            */
2672            public static com.liferay.portal.model.Layout fetchByG_P_SPLU(
2673                    long groupId, boolean privateLayout,
2674                    java.lang.String sourcePrototypeLayoutUuid)
2675                    throws com.liferay.portal.kernel.exception.SystemException {
2676                    return getPersistence()
2677                                       .fetchByG_P_SPLU(groupId, privateLayout,
2678                            sourcePrototypeLayoutUuid);
2679            }
2680    
2681            /**
2682            * 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.
2683            *
2684            * @param groupId the group ID
2685            * @param privateLayout the private layout
2686            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2687            * @param retrieveFromCache whether to use the finder cache
2688            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2689            * @throws SystemException if a system exception occurred
2690            */
2691            public static com.liferay.portal.model.Layout fetchByG_P_SPLU(
2692                    long groupId, boolean privateLayout,
2693                    java.lang.String sourcePrototypeLayoutUuid, boolean retrieveFromCache)
2694                    throws com.liferay.portal.kernel.exception.SystemException {
2695                    return getPersistence()
2696                                       .fetchByG_P_SPLU(groupId, privateLayout,
2697                            sourcePrototypeLayoutUuid, retrieveFromCache);
2698            }
2699    
2700            /**
2701            * Removes the layout where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63; from the database.
2702            *
2703            * @param groupId the group ID
2704            * @param privateLayout the private layout
2705            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2706            * @return the layout that was removed
2707            * @throws SystemException if a system exception occurred
2708            */
2709            public static com.liferay.portal.model.Layout removeByG_P_SPLU(
2710                    long groupId, boolean privateLayout,
2711                    java.lang.String sourcePrototypeLayoutUuid)
2712                    throws com.liferay.portal.NoSuchLayoutException,
2713                            com.liferay.portal.kernel.exception.SystemException {
2714                    return getPersistence()
2715                                       .removeByG_P_SPLU(groupId, privateLayout,
2716                            sourcePrototypeLayoutUuid);
2717            }
2718    
2719            /**
2720            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63;.
2721            *
2722            * @param groupId the group ID
2723            * @param privateLayout the private layout
2724            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2725            * @return the number of matching layouts
2726            * @throws SystemException if a system exception occurred
2727            */
2728            public static int countByG_P_SPLU(long groupId, boolean privateLayout,
2729                    java.lang.String sourcePrototypeLayoutUuid)
2730                    throws com.liferay.portal.kernel.exception.SystemException {
2731                    return getPersistence()
2732                                       .countByG_P_SPLU(groupId, privateLayout,
2733                            sourcePrototypeLayoutUuid);
2734            }
2735    
2736            /**
2737            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2738            *
2739            * @param groupId the group ID
2740            * @param privateLayout the private layout
2741            * @param parentLayoutId the parent layout ID
2742            * @param priority the priority
2743            * @return the matching layouts
2744            * @throws SystemException if a system exception occurred
2745            */
2746            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP(
2747                    long groupId, boolean privateLayout, long parentLayoutId, int priority)
2748                    throws com.liferay.portal.kernel.exception.SystemException {
2749                    return getPersistence()
2750                                       .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2751                            priority);
2752            }
2753    
2754            /**
2755            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2756            *
2757            * <p>
2758            * 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.
2759            * </p>
2760            *
2761            * @param groupId the group ID
2762            * @param privateLayout the private layout
2763            * @param parentLayoutId the parent layout ID
2764            * @param priority the priority
2765            * @param start the lower bound of the range of layouts
2766            * @param end the upper bound of the range of layouts (not inclusive)
2767            * @return the range of matching layouts
2768            * @throws SystemException if a system exception occurred
2769            */
2770            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP(
2771                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2772                    int start, int end)
2773                    throws com.liferay.portal.kernel.exception.SystemException {
2774                    return getPersistence()
2775                                       .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2776                            priority, start, end);
2777            }
2778    
2779            /**
2780            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2781            *
2782            * <p>
2783            * 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.
2784            * </p>
2785            *
2786            * @param groupId the group ID
2787            * @param privateLayout the private layout
2788            * @param parentLayoutId the parent layout ID
2789            * @param priority the priority
2790            * @param start the lower bound of the range of layouts
2791            * @param end the upper bound of the range of layouts (not inclusive)
2792            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2793            * @return the ordered range of matching layouts
2794            * @throws SystemException if a system exception occurred
2795            */
2796            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP(
2797                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2798                    int start, int end,
2799                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2800                    throws com.liferay.portal.kernel.exception.SystemException {
2801                    return getPersistence()
2802                                       .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2803                            priority, start, end, orderByComparator);
2804            }
2805    
2806            /**
2807            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2808            *
2809            * @param groupId the group ID
2810            * @param privateLayout the private layout
2811            * @param parentLayoutId the parent layout ID
2812            * @param priority the priority
2813            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2814            * @return the first matching layout
2815            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2816            * @throws SystemException if a system exception occurred
2817            */
2818            public static com.liferay.portal.model.Layout findByG_P_P_LtP_First(
2819                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2820                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2821                    throws com.liferay.portal.NoSuchLayoutException,
2822                            com.liferay.portal.kernel.exception.SystemException {
2823                    return getPersistence()
2824                                       .findByG_P_P_LtP_First(groupId, privateLayout,
2825                            parentLayoutId, priority, orderByComparator);
2826            }
2827    
2828            /**
2829            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2830            *
2831            * @param groupId the group ID
2832            * @param privateLayout the private layout
2833            * @param parentLayoutId the parent layout ID
2834            * @param priority the priority
2835            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2836            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
2837            * @throws SystemException if a system exception occurred
2838            */
2839            public static com.liferay.portal.model.Layout fetchByG_P_P_LtP_First(
2840                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2841                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2842                    throws com.liferay.portal.kernel.exception.SystemException {
2843                    return getPersistence()
2844                                       .fetchByG_P_P_LtP_First(groupId, privateLayout,
2845                            parentLayoutId, priority, orderByComparator);
2846            }
2847    
2848            /**
2849            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2850            *
2851            * @param groupId the group ID
2852            * @param privateLayout the private layout
2853            * @param parentLayoutId the parent layout ID
2854            * @param priority the priority
2855            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2856            * @return the last matching layout
2857            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2858            * @throws SystemException if a system exception occurred
2859            */
2860            public static com.liferay.portal.model.Layout findByG_P_P_LtP_Last(
2861                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2862                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2863                    throws com.liferay.portal.NoSuchLayoutException,
2864                            com.liferay.portal.kernel.exception.SystemException {
2865                    return getPersistence()
2866                                       .findByG_P_P_LtP_Last(groupId, privateLayout,
2867                            parentLayoutId, priority, orderByComparator);
2868            }
2869    
2870            /**
2871            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2872            *
2873            * @param groupId the group ID
2874            * @param privateLayout the private layout
2875            * @param parentLayoutId the parent layout ID
2876            * @param priority the priority
2877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2878            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
2879            * @throws SystemException if a system exception occurred
2880            */
2881            public static com.liferay.portal.model.Layout fetchByG_P_P_LtP_Last(
2882                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2883                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2884                    throws com.liferay.portal.kernel.exception.SystemException {
2885                    return getPersistence()
2886                                       .fetchByG_P_P_LtP_Last(groupId, privateLayout,
2887                            parentLayoutId, priority, orderByComparator);
2888            }
2889    
2890            /**
2891            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2892            *
2893            * @param plid the primary key of the current layout
2894            * @param groupId the group ID
2895            * @param privateLayout the private layout
2896            * @param parentLayoutId the parent layout ID
2897            * @param priority the priority
2898            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2899            * @return the previous, current, and next layout
2900            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2901            * @throws SystemException if a system exception occurred
2902            */
2903            public static com.liferay.portal.model.Layout[] findByG_P_P_LtP_PrevAndNext(
2904                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2905                    int priority,
2906                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2907                    throws com.liferay.portal.NoSuchLayoutException,
2908                            com.liferay.portal.kernel.exception.SystemException {
2909                    return getPersistence()
2910                                       .findByG_P_P_LtP_PrevAndNext(plid, groupId, privateLayout,
2911                            parentLayoutId, priority, orderByComparator);
2912            }
2913    
2914            /**
2915            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2916            *
2917            * @param groupId the group ID
2918            * @param privateLayout the private layout
2919            * @param parentLayoutId the parent layout ID
2920            * @param priority the priority
2921            * @return the matching layouts that the user has permission to view
2922            * @throws SystemException if a system exception occurred
2923            */
2924            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP(
2925                    long groupId, boolean privateLayout, long parentLayoutId, int priority)
2926                    throws com.liferay.portal.kernel.exception.SystemException {
2927                    return getPersistence()
2928                                       .filterFindByG_P_P_LtP(groupId, privateLayout,
2929                            parentLayoutId, priority);
2930            }
2931    
2932            /**
2933            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2934            *
2935            * <p>
2936            * 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.
2937            * </p>
2938            *
2939            * @param groupId the group ID
2940            * @param privateLayout the private layout
2941            * @param parentLayoutId the parent layout ID
2942            * @param priority the priority
2943            * @param start the lower bound of the range of layouts
2944            * @param end the upper bound of the range of layouts (not inclusive)
2945            * @return the range of matching layouts that the user has permission to view
2946            * @throws SystemException if a system exception occurred
2947            */
2948            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP(
2949                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2950                    int start, int end)
2951                    throws com.liferay.portal.kernel.exception.SystemException {
2952                    return getPersistence()
2953                                       .filterFindByG_P_P_LtP(groupId, privateLayout,
2954                            parentLayoutId, priority, start, end);
2955            }
2956    
2957            /**
2958            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2959            *
2960            * <p>
2961            * 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.
2962            * </p>
2963            *
2964            * @param groupId the group ID
2965            * @param privateLayout the private layout
2966            * @param parentLayoutId the parent layout ID
2967            * @param priority the priority
2968            * @param start the lower bound of the range of layouts
2969            * @param end the upper bound of the range of layouts (not inclusive)
2970            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2971            * @return the ordered range of matching layouts that the user has permission to view
2972            * @throws SystemException if a system exception occurred
2973            */
2974            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP(
2975                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2976                    int start, int end,
2977                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2978                    throws com.liferay.portal.kernel.exception.SystemException {
2979                    return getPersistence()
2980                                       .filterFindByG_P_P_LtP(groupId, privateLayout,
2981                            parentLayoutId, priority, start, end, orderByComparator);
2982            }
2983    
2984            /**
2985            * 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; and priority &le; &#63;.
2986            *
2987            * @param plid the primary key of the current layout
2988            * @param groupId the group ID
2989            * @param privateLayout the private layout
2990            * @param parentLayoutId the parent layout ID
2991            * @param priority the priority
2992            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2993            * @return the previous, current, and next layout
2994            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2995            * @throws SystemException if a system exception occurred
2996            */
2997            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_LtP_PrevAndNext(
2998                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2999                    int priority,
3000                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3001                    throws com.liferay.portal.NoSuchLayoutException,
3002                            com.liferay.portal.kernel.exception.SystemException {
3003                    return getPersistence()
3004                                       .filterFindByG_P_P_LtP_PrevAndNext(plid, groupId,
3005                            privateLayout, parentLayoutId, priority, orderByComparator);
3006            }
3007    
3008            /**
3009            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63; from the database.
3010            *
3011            * @param groupId the group ID
3012            * @param privateLayout the private layout
3013            * @param parentLayoutId the parent layout ID
3014            * @param priority the priority
3015            * @throws SystemException if a system exception occurred
3016            */
3017            public static void removeByG_P_P_LtP(long groupId, boolean privateLayout,
3018                    long parentLayoutId, int priority)
3019                    throws com.liferay.portal.kernel.exception.SystemException {
3020                    getPersistence()
3021                            .removeByG_P_P_LtP(groupId, privateLayout, parentLayoutId, priority);
3022            }
3023    
3024            /**
3025            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
3026            *
3027            * @param groupId the group ID
3028            * @param privateLayout the private layout
3029            * @param parentLayoutId the parent layout ID
3030            * @param priority the priority
3031            * @return the number of matching layouts
3032            * @throws SystemException if a system exception occurred
3033            */
3034            public static int countByG_P_P_LtP(long groupId, boolean privateLayout,
3035                    long parentLayoutId, int priority)
3036                    throws com.liferay.portal.kernel.exception.SystemException {
3037                    return getPersistence()
3038                                       .countByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
3039                            priority);
3040            }
3041    
3042            /**
3043            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
3044            *
3045            * @param groupId the group ID
3046            * @param privateLayout the private layout
3047            * @param parentLayoutId the parent layout ID
3048            * @param priority the priority
3049            * @return the number of matching layouts that the user has permission to view
3050            * @throws SystemException if a system exception occurred
3051            */
3052            public static int filterCountByG_P_P_LtP(long groupId,
3053                    boolean privateLayout, long parentLayoutId, int priority)
3054                    throws com.liferay.portal.kernel.exception.SystemException {
3055                    return getPersistence()
3056                                       .filterCountByG_P_P_LtP(groupId, privateLayout,
3057                            parentLayoutId, priority);
3058            }
3059    
3060            /**
3061            * Caches the layout in the entity cache if it is enabled.
3062            *
3063            * @param layout the layout
3064            */
3065            public static void cacheResult(com.liferay.portal.model.Layout layout) {
3066                    getPersistence().cacheResult(layout);
3067            }
3068    
3069            /**
3070            * Caches the layouts in the entity cache if it is enabled.
3071            *
3072            * @param layouts the layouts
3073            */
3074            public static void cacheResult(
3075                    java.util.List<com.liferay.portal.model.Layout> layouts) {
3076                    getPersistence().cacheResult(layouts);
3077            }
3078    
3079            /**
3080            * Creates a new layout with the primary key. Does not add the layout to the database.
3081            *
3082            * @param plid the primary key for the new layout
3083            * @return the new layout
3084            */
3085            public static com.liferay.portal.model.Layout create(long plid) {
3086                    return getPersistence().create(plid);
3087            }
3088    
3089            /**
3090            * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners.
3091            *
3092            * @param plid the primary key of the layout
3093            * @return the layout that was removed
3094            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
3095            * @throws SystemException if a system exception occurred
3096            */
3097            public static com.liferay.portal.model.Layout remove(long plid)
3098                    throws com.liferay.portal.NoSuchLayoutException,
3099                            com.liferay.portal.kernel.exception.SystemException {
3100                    return getPersistence().remove(plid);
3101            }
3102    
3103            public static com.liferay.portal.model.Layout updateImpl(
3104                    com.liferay.portal.model.Layout layout)
3105                    throws com.liferay.portal.kernel.exception.SystemException {
3106                    return getPersistence().updateImpl(layout);
3107            }
3108    
3109            /**
3110            * Returns the layout with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
3111            *
3112            * @param plid the primary key of the layout
3113            * @return the layout
3114            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
3115            * @throws SystemException if a system exception occurred
3116            */
3117            public static com.liferay.portal.model.Layout findByPrimaryKey(long plid)
3118                    throws com.liferay.portal.NoSuchLayoutException,
3119                            com.liferay.portal.kernel.exception.SystemException {
3120                    return getPersistence().findByPrimaryKey(plid);
3121            }
3122    
3123            /**
3124            * Returns the layout with the primary key or returns <code>null</code> if it could not be found.
3125            *
3126            * @param plid the primary key of the layout
3127            * @return the layout, or <code>null</code> if a layout with the primary key could not be found
3128            * @throws SystemException if a system exception occurred
3129            */
3130            public static com.liferay.portal.model.Layout fetchByPrimaryKey(long plid)
3131                    throws com.liferay.portal.kernel.exception.SystemException {
3132                    return getPersistence().fetchByPrimaryKey(plid);
3133            }
3134    
3135            /**
3136            * Returns all the layouts.
3137            *
3138            * @return the layouts
3139            * @throws SystemException if a system exception occurred
3140            */
3141            public static java.util.List<com.liferay.portal.model.Layout> findAll()
3142                    throws com.liferay.portal.kernel.exception.SystemException {
3143                    return getPersistence().findAll();
3144            }
3145    
3146            /**
3147            * Returns a range of all the layouts.
3148            *
3149            * <p>
3150            * 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.
3151            * </p>
3152            *
3153            * @param start the lower bound of the range of layouts
3154            * @param end the upper bound of the range of layouts (not inclusive)
3155            * @return the range of layouts
3156            * @throws SystemException if a system exception occurred
3157            */
3158            public static java.util.List<com.liferay.portal.model.Layout> findAll(
3159                    int start, int end)
3160                    throws com.liferay.portal.kernel.exception.SystemException {
3161                    return getPersistence().findAll(start, end);
3162            }
3163    
3164            /**
3165            * Returns an ordered range of all the layouts.
3166            *
3167            * <p>
3168            * 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.
3169            * </p>
3170            *
3171            * @param start the lower bound of the range of layouts
3172            * @param end the upper bound of the range of layouts (not inclusive)
3173            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3174            * @return the ordered range of layouts
3175            * @throws SystemException if a system exception occurred
3176            */
3177            public static java.util.List<com.liferay.portal.model.Layout> findAll(
3178                    int start, int end,
3179                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3180                    throws com.liferay.portal.kernel.exception.SystemException {
3181                    return getPersistence().findAll(start, end, orderByComparator);
3182            }
3183    
3184            /**
3185            * Removes all the layouts from the database.
3186            *
3187            * @throws SystemException if a system exception occurred
3188            */
3189            public static void removeAll()
3190                    throws com.liferay.portal.kernel.exception.SystemException {
3191                    getPersistence().removeAll();
3192            }
3193    
3194            /**
3195            * Returns the number of layouts.
3196            *
3197            * @return the number of layouts
3198            * @throws SystemException if a system exception occurred
3199            */
3200            public static int countAll()
3201                    throws com.liferay.portal.kernel.exception.SystemException {
3202                    return getPersistence().countAll();
3203            }
3204    
3205            public static LayoutPersistence getPersistence() {
3206                    if (_persistence == null) {
3207                            _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName());
3208    
3209                            ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence");
3210                    }
3211    
3212                    return _persistence;
3213            }
3214    
3215            /**
3216             * @deprecated As of 6.2.0
3217             */
3218            public void setPersistence(LayoutPersistence persistence) {
3219            }
3220    
3221            private static LayoutPersistence _persistence;
3222    }