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 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.
1630            *
1631            * @param groupId the group ID
1632            * @param privateLayout the private layout
1633            * @param layoutId the layout ID
1634            * @return the matching layout
1635            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1636            * @throws SystemException if a system exception occurred
1637            */
1638            public static com.liferay.portal.model.Layout findByG_P_L(long groupId,
1639                    boolean privateLayout, long layoutId)
1640                    throws com.liferay.portal.NoSuchLayoutException,
1641                            com.liferay.portal.kernel.exception.SystemException {
1642                    return getPersistence().findByG_P_L(groupId, privateLayout, layoutId);
1643            }
1644    
1645            /**
1646            * 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.
1647            *
1648            * @param groupId the group ID
1649            * @param privateLayout the private layout
1650            * @param layoutId the layout ID
1651            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1652            * @throws SystemException if a system exception occurred
1653            */
1654            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1655                    boolean privateLayout, long layoutId)
1656                    throws com.liferay.portal.kernel.exception.SystemException {
1657                    return getPersistence().fetchByG_P_L(groupId, privateLayout, layoutId);
1658            }
1659    
1660            /**
1661            * 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.
1662            *
1663            * @param groupId the group ID
1664            * @param privateLayout the private layout
1665            * @param layoutId the layout ID
1666            * @param retrieveFromCache whether to use the finder cache
1667            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1668            * @throws SystemException if a system exception occurred
1669            */
1670            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1671                    boolean privateLayout, long layoutId, boolean retrieveFromCache)
1672                    throws com.liferay.portal.kernel.exception.SystemException {
1673                    return getPersistence()
1674                                       .fetchByG_P_L(groupId, privateLayout, layoutId,
1675                            retrieveFromCache);
1676            }
1677    
1678            /**
1679            * Removes the layout where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; from the database.
1680            *
1681            * @param groupId the group ID
1682            * @param privateLayout the private layout
1683            * @param layoutId the layout ID
1684            * @return the layout that was removed
1685            * @throws SystemException if a system exception occurred
1686            */
1687            public static com.liferay.portal.model.Layout removeByG_P_L(long groupId,
1688                    boolean privateLayout, long layoutId)
1689                    throws com.liferay.portal.NoSuchLayoutException,
1690                            com.liferay.portal.kernel.exception.SystemException {
1691                    return getPersistence().removeByG_P_L(groupId, privateLayout, layoutId);
1692            }
1693    
1694            /**
1695            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
1696            *
1697            * @param groupId the group ID
1698            * @param privateLayout the private layout
1699            * @param layoutId the layout ID
1700            * @return the number of matching layouts
1701            * @throws SystemException if a system exception occurred
1702            */
1703            public static int countByG_P_L(long groupId, boolean privateLayout,
1704                    long layoutId)
1705                    throws com.liferay.portal.kernel.exception.SystemException {
1706                    return getPersistence().countByG_P_L(groupId, privateLayout, layoutId);
1707            }
1708    
1709            /**
1710            * 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.
1711            *
1712            * @param groupId the group ID
1713            * @param privateLayout the private layout
1714            * @param friendlyURL the friendly u r l
1715            * @return the matching layout
1716            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1717            * @throws SystemException if a system exception occurred
1718            */
1719            public static com.liferay.portal.model.Layout findByG_P_F(long groupId,
1720                    boolean privateLayout, java.lang.String friendlyURL)
1721                    throws com.liferay.portal.NoSuchLayoutException,
1722                            com.liferay.portal.kernel.exception.SystemException {
1723                    return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL);
1724            }
1725    
1726            /**
1727            * 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.
1728            *
1729            * @param groupId the group ID
1730            * @param privateLayout the private layout
1731            * @param friendlyURL the friendly u r l
1732            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1733            * @throws SystemException if a system exception occurred
1734            */
1735            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1736                    boolean privateLayout, java.lang.String friendlyURL)
1737                    throws com.liferay.portal.kernel.exception.SystemException {
1738                    return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL);
1739            }
1740    
1741            /**
1742            * 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.
1743            *
1744            * @param groupId the group ID
1745            * @param privateLayout the private layout
1746            * @param friendlyURL the friendly u r l
1747            * @param retrieveFromCache whether to use the finder cache
1748            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1749            * @throws SystemException if a system exception occurred
1750            */
1751            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1752                    boolean privateLayout, java.lang.String friendlyURL,
1753                    boolean retrieveFromCache)
1754                    throws com.liferay.portal.kernel.exception.SystemException {
1755                    return getPersistence()
1756                                       .fetchByG_P_F(groupId, privateLayout, friendlyURL,
1757                            retrieveFromCache);
1758            }
1759    
1760            /**
1761            * Removes the layout where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; from the database.
1762            *
1763            * @param groupId the group ID
1764            * @param privateLayout the private layout
1765            * @param friendlyURL the friendly u r l
1766            * @return the layout that was removed
1767            * @throws SystemException if a system exception occurred
1768            */
1769            public static com.liferay.portal.model.Layout removeByG_P_F(long groupId,
1770                    boolean privateLayout, java.lang.String friendlyURL)
1771                    throws com.liferay.portal.NoSuchLayoutException,
1772                            com.liferay.portal.kernel.exception.SystemException {
1773                    return getPersistence()
1774                                       .removeByG_P_F(groupId, privateLayout, friendlyURL);
1775            }
1776    
1777            /**
1778            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1779            *
1780            * @param groupId the group ID
1781            * @param privateLayout the private layout
1782            * @param friendlyURL the friendly u r l
1783            * @return the number of matching layouts
1784            * @throws SystemException if a system exception occurred
1785            */
1786            public static int countByG_P_F(long groupId, boolean privateLayout,
1787                    java.lang.String friendlyURL)
1788                    throws com.liferay.portal.kernel.exception.SystemException {
1789                    return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL);
1790            }
1791    
1792            /**
1793            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1794            *
1795            * @param groupId the group ID
1796            * @param privateLayout the private layout
1797            * @param parentLayoutId the parent layout ID
1798            * @return the matching layouts
1799            * @throws SystemException if a system exception occurred
1800            */
1801            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1802                    long groupId, boolean privateLayout, long parentLayoutId)
1803                    throws com.liferay.portal.kernel.exception.SystemException {
1804                    return getPersistence()
1805                                       .findByG_P_P(groupId, privateLayout, parentLayoutId);
1806            }
1807    
1808            /**
1809            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1810            *
1811            * <p>
1812            * 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.
1813            * </p>
1814            *
1815            * @param groupId the group ID
1816            * @param privateLayout the private layout
1817            * @param parentLayoutId the parent layout ID
1818            * @param start the lower bound of the range of layouts
1819            * @param end the upper bound of the range of layouts (not inclusive)
1820            * @return the range of matching layouts
1821            * @throws SystemException if a system exception occurred
1822            */
1823            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1824                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1825                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1826                    return getPersistence()
1827                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1828                            end);
1829            }
1830    
1831            /**
1832            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1833            *
1834            * <p>
1835            * 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.
1836            * </p>
1837            *
1838            * @param groupId the group ID
1839            * @param privateLayout the private layout
1840            * @param parentLayoutId the parent layout ID
1841            * @param start the lower bound of the range of layouts
1842            * @param end the upper bound of the range of layouts (not inclusive)
1843            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1844            * @return the ordered range of matching layouts
1845            * @throws SystemException if a system exception occurred
1846            */
1847            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1848                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1849                    int end,
1850                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1851                    throws com.liferay.portal.kernel.exception.SystemException {
1852                    return getPersistence()
1853                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1854                            end, orderByComparator);
1855            }
1856    
1857            /**
1858            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1859            *
1860            * @param groupId the group ID
1861            * @param privateLayout the private layout
1862            * @param parentLayoutId the parent layout ID
1863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1864            * @return the first matching layout
1865            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1866            * @throws SystemException if a system exception occurred
1867            */
1868            public static com.liferay.portal.model.Layout findByG_P_P_First(
1869                    long groupId, boolean privateLayout, long parentLayoutId,
1870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1871                    throws com.liferay.portal.NoSuchLayoutException,
1872                            com.liferay.portal.kernel.exception.SystemException {
1873                    return getPersistence()
1874                                       .findByG_P_P_First(groupId, privateLayout, parentLayoutId,
1875                            orderByComparator);
1876            }
1877    
1878            /**
1879            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1880            *
1881            * @param groupId the group ID
1882            * @param privateLayout the private layout
1883            * @param parentLayoutId the parent layout ID
1884            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1885            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1886            * @throws SystemException if a system exception occurred
1887            */
1888            public static com.liferay.portal.model.Layout fetchByG_P_P_First(
1889                    long groupId, boolean privateLayout, long parentLayoutId,
1890                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1891                    throws com.liferay.portal.kernel.exception.SystemException {
1892                    return getPersistence()
1893                                       .fetchByG_P_P_First(groupId, privateLayout, parentLayoutId,
1894                            orderByComparator);
1895            }
1896    
1897            /**
1898            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1899            *
1900            * @param groupId the group ID
1901            * @param privateLayout the private layout
1902            * @param parentLayoutId the parent layout ID
1903            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1904            * @return the last matching layout
1905            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1906            * @throws SystemException if a system exception occurred
1907            */
1908            public static com.liferay.portal.model.Layout findByG_P_P_Last(
1909                    long groupId, boolean privateLayout, long parentLayoutId,
1910                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1911                    throws com.liferay.portal.NoSuchLayoutException,
1912                            com.liferay.portal.kernel.exception.SystemException {
1913                    return getPersistence()
1914                                       .findByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1915                            orderByComparator);
1916            }
1917    
1918            /**
1919            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1920            *
1921            * @param groupId the group ID
1922            * @param privateLayout the private layout
1923            * @param parentLayoutId the parent layout ID
1924            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1925            * @return the last 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_P_Last(
1929                    long groupId, boolean privateLayout, long parentLayoutId,
1930                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1931                    throws com.liferay.portal.kernel.exception.SystemException {
1932                    return getPersistence()
1933                                       .fetchByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1934                            orderByComparator);
1935            }
1936    
1937            /**
1938            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1939            *
1940            * @param plid the primary key of the current layout
1941            * @param groupId the group ID
1942            * @param privateLayout the private layout
1943            * @param parentLayoutId the parent layout ID
1944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1945            * @return the previous, current, and next layout
1946            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1947            * @throws SystemException if a system exception occurred
1948            */
1949            public static com.liferay.portal.model.Layout[] findByG_P_P_PrevAndNext(
1950                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1951                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1952                    throws com.liferay.portal.NoSuchLayoutException,
1953                            com.liferay.portal.kernel.exception.SystemException {
1954                    return getPersistence()
1955                                       .findByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1956                            parentLayoutId, orderByComparator);
1957            }
1958    
1959            /**
1960            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1961            *
1962            * @param groupId the group ID
1963            * @param privateLayout the private layout
1964            * @param parentLayoutId the parent layout ID
1965            * @return the matching layouts that the user has permission to view
1966            * @throws SystemException if a system exception occurred
1967            */
1968            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1969                    long groupId, boolean privateLayout, long parentLayoutId)
1970                    throws com.liferay.portal.kernel.exception.SystemException {
1971                    return getPersistence()
1972                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId);
1973            }
1974    
1975            /**
1976            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1977            *
1978            * <p>
1979            * 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.
1980            * </p>
1981            *
1982            * @param groupId the group ID
1983            * @param privateLayout the private layout
1984            * @param parentLayoutId the parent layout ID
1985            * @param start the lower bound of the range of layouts
1986            * @param end the upper bound of the range of layouts (not inclusive)
1987            * @return the range of matching layouts that the user has permission to view
1988            * @throws SystemException if a system exception occurred
1989            */
1990            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1991                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1992                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1993                    return getPersistence()
1994                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1995                            start, end);
1996            }
1997    
1998            /**
1999            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2000            *
2001            * <p>
2002            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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.
2003            * </p>
2004            *
2005            * @param groupId the group ID
2006            * @param privateLayout the private layout
2007            * @param parentLayoutId the parent layout ID
2008            * @param start the lower bound of the range of layouts
2009            * @param end the upper bound of the range of layouts (not inclusive)
2010            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2011            * @return the ordered range of matching layouts that the user has permission to view
2012            * @throws SystemException if a system exception occurred
2013            */
2014            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
2015                    long groupId, boolean privateLayout, long parentLayoutId, int start,
2016                    int end,
2017                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2018                    throws com.liferay.portal.kernel.exception.SystemException {
2019                    return getPersistence()
2020                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
2021                            start, end, orderByComparator);
2022            }
2023    
2024            /**
2025            * Returns the layouts before and after the current layout in the ordered set of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2026            *
2027            * @param plid the primary key of the current layout
2028            * @param groupId the group ID
2029            * @param privateLayout the private layout
2030            * @param parentLayoutId the parent layout ID
2031            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2032            * @return the previous, current, and next layout
2033            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2034            * @throws SystemException if a system exception occurred
2035            */
2036            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_PrevAndNext(
2037                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2038                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2039                    throws com.liferay.portal.NoSuchLayoutException,
2040                            com.liferay.portal.kernel.exception.SystemException {
2041                    return getPersistence()
2042                                       .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout,
2043                            parentLayoutId, orderByComparator);
2044            }
2045    
2046            /**
2047            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; from the database.
2048            *
2049            * @param groupId the group ID
2050            * @param privateLayout the private layout
2051            * @param parentLayoutId the parent layout ID
2052            * @throws SystemException if a system exception occurred
2053            */
2054            public static void removeByG_P_P(long groupId, boolean privateLayout,
2055                    long parentLayoutId)
2056                    throws com.liferay.portal.kernel.exception.SystemException {
2057                    getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId);
2058            }
2059    
2060            /**
2061            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2062            *
2063            * @param groupId the group ID
2064            * @param privateLayout the private layout
2065            * @param parentLayoutId the parent layout ID
2066            * @return the number of matching layouts
2067            * @throws SystemException if a system exception occurred
2068            */
2069            public static int countByG_P_P(long groupId, boolean privateLayout,
2070                    long parentLayoutId)
2071                    throws com.liferay.portal.kernel.exception.SystemException {
2072                    return getPersistence()
2073                                       .countByG_P_P(groupId, privateLayout, parentLayoutId);
2074            }
2075    
2076            /**
2077            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2078            *
2079            * @param groupId the group ID
2080            * @param privateLayout the private layout
2081            * @param parentLayoutId the parent layout ID
2082            * @return the number of matching layouts that the user has permission to view
2083            * @throws SystemException if a system exception occurred
2084            */
2085            public static int filterCountByG_P_P(long groupId, boolean privateLayout,
2086                    long parentLayoutId)
2087                    throws com.liferay.portal.kernel.exception.SystemException {
2088                    return getPersistence()
2089                                       .filterCountByG_P_P(groupId, privateLayout, parentLayoutId);
2090            }
2091    
2092            /**
2093            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2094            *
2095            * @param groupId the group ID
2096            * @param privateLayout the private layout
2097            * @param type the type
2098            * @return the matching layouts
2099            * @throws SystemException if a system exception occurred
2100            */
2101            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
2102                    long groupId, boolean privateLayout, java.lang.String type)
2103                    throws com.liferay.portal.kernel.exception.SystemException {
2104                    return getPersistence().findByG_P_T(groupId, privateLayout, type);
2105            }
2106    
2107            /**
2108            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2109            *
2110            * <p>
2111            * 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.
2112            * </p>
2113            *
2114            * @param groupId the group ID
2115            * @param privateLayout the private layout
2116            * @param type the type
2117            * @param start the lower bound of the range of layouts
2118            * @param end the upper bound of the range of layouts (not inclusive)
2119            * @return the range of matching layouts
2120            * @throws SystemException if a system exception occurred
2121            */
2122            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
2123                    long groupId, boolean privateLayout, java.lang.String type, int start,
2124                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2125                    return getPersistence()
2126                                       .findByG_P_T(groupId, privateLayout, type, start, end);
2127            }
2128    
2129            /**
2130            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2131            *
2132            * <p>
2133            * 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.
2134            * </p>
2135            *
2136            * @param groupId the group ID
2137            * @param privateLayout the private layout
2138            * @param type the type
2139            * @param start the lower bound of the range of layouts
2140            * @param end the upper bound of the range of layouts (not inclusive)
2141            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2142            * @return the ordered range of matching layouts
2143            * @throws SystemException if a system exception occurred
2144            */
2145            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
2146                    long groupId, boolean privateLayout, java.lang.String type, int start,
2147                    int end,
2148                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2149                    throws com.liferay.portal.kernel.exception.SystemException {
2150                    return getPersistence()
2151                                       .findByG_P_T(groupId, privateLayout, type, start, end,
2152                            orderByComparator);
2153            }
2154    
2155            /**
2156            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2157            *
2158            * @param groupId the group ID
2159            * @param privateLayout the private layout
2160            * @param type the type
2161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2162            * @return the first 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_T_First(
2167                    long groupId, boolean privateLayout, java.lang.String type,
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_T_First(groupId, privateLayout, type,
2173                            orderByComparator);
2174            }
2175    
2176            /**
2177            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2178            *
2179            * @param groupId the group ID
2180            * @param privateLayout the private layout
2181            * @param type the type
2182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2183            * @return the first 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_T_First(
2187                    long groupId, boolean privateLayout, java.lang.String type,
2188                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2189                    throws com.liferay.portal.kernel.exception.SystemException {
2190                    return getPersistence()
2191                                       .fetchByG_P_T_First(groupId, privateLayout, type,
2192                            orderByComparator);
2193            }
2194    
2195            /**
2196            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2197            *
2198            * @param groupId the group ID
2199            * @param privateLayout the private layout
2200            * @param type the type
2201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2202            * @return the last matching layout
2203            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2204            * @throws SystemException if a system exception occurred
2205            */
2206            public static com.liferay.portal.model.Layout findByG_P_T_Last(
2207                    long groupId, boolean privateLayout, java.lang.String type,
2208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2209                    throws com.liferay.portal.NoSuchLayoutException,
2210                            com.liferay.portal.kernel.exception.SystemException {
2211                    return getPersistence()
2212                                       .findByG_P_T_Last(groupId, privateLayout, type,
2213                            orderByComparator);
2214            }
2215    
2216            /**
2217            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2218            *
2219            * @param groupId the group ID
2220            * @param privateLayout the private layout
2221            * @param type the type
2222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2223            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
2224            * @throws SystemException if a system exception occurred
2225            */
2226            public static com.liferay.portal.model.Layout fetchByG_P_T_Last(
2227                    long groupId, boolean privateLayout, java.lang.String type,
2228                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2229                    throws com.liferay.portal.kernel.exception.SystemException {
2230                    return getPersistence()
2231                                       .fetchByG_P_T_Last(groupId, privateLayout, type,
2232                            orderByComparator);
2233            }
2234    
2235            /**
2236            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2237            *
2238            * @param plid the primary key of the current layout
2239            * @param groupId the group ID
2240            * @param privateLayout the private layout
2241            * @param type the type
2242            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2243            * @return the previous, current, and next layout
2244            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2245            * @throws SystemException if a system exception occurred
2246            */
2247            public static com.liferay.portal.model.Layout[] findByG_P_T_PrevAndNext(
2248                    long plid, long groupId, boolean privateLayout, java.lang.String type,
2249                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2250                    throws com.liferay.portal.NoSuchLayoutException,
2251                            com.liferay.portal.kernel.exception.SystemException {
2252                    return getPersistence()
2253                                       .findByG_P_T_PrevAndNext(plid, groupId, privateLayout, type,
2254                            orderByComparator);
2255            }
2256    
2257            /**
2258            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2259            *
2260            * @param groupId the group ID
2261            * @param privateLayout the private layout
2262            * @param type the type
2263            * @return the matching layouts that the user has permission to view
2264            * @throws SystemException if a system exception occurred
2265            */
2266            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
2267                    long groupId, boolean privateLayout, java.lang.String type)
2268                    throws com.liferay.portal.kernel.exception.SystemException {
2269                    return getPersistence().filterFindByG_P_T(groupId, privateLayout, type);
2270            }
2271    
2272            /**
2273            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2274            *
2275            * <p>
2276            * 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.
2277            * </p>
2278            *
2279            * @param groupId the group ID
2280            * @param privateLayout the private layout
2281            * @param type the type
2282            * @param start the lower bound of the range of layouts
2283            * @param end the upper bound of the range of layouts (not inclusive)
2284            * @return the range of matching layouts that the user has permission to view
2285            * @throws SystemException if a system exception occurred
2286            */
2287            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
2288                    long groupId, boolean privateLayout, java.lang.String type, int start,
2289                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2290                    return getPersistence()
2291                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end);
2292            }
2293    
2294            /**
2295            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2296            *
2297            * <p>
2298            * 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.
2299            * </p>
2300            *
2301            * @param groupId the group ID
2302            * @param privateLayout the private layout
2303            * @param type the type
2304            * @param start the lower bound of the range of layouts
2305            * @param end the upper bound of the range of layouts (not inclusive)
2306            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2307            * @return the ordered range of matching layouts that the user has permission to view
2308            * @throws SystemException if a system exception occurred
2309            */
2310            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
2311                    long groupId, boolean privateLayout, java.lang.String type, int start,
2312                    int end,
2313                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2314                    throws com.liferay.portal.kernel.exception.SystemException {
2315                    return getPersistence()
2316                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end,
2317                            orderByComparator);
2318            }
2319    
2320            /**
2321            * 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;.
2322            *
2323            * @param plid the primary key of the current layout
2324            * @param groupId the group ID
2325            * @param privateLayout the private layout
2326            * @param type the type
2327            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2328            * @return the previous, current, and next layout
2329            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2330            * @throws SystemException if a system exception occurred
2331            */
2332            public static com.liferay.portal.model.Layout[] filterFindByG_P_T_PrevAndNext(
2333                    long plid, long groupId, boolean privateLayout, java.lang.String type,
2334                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2335                    throws com.liferay.portal.NoSuchLayoutException,
2336                            com.liferay.portal.kernel.exception.SystemException {
2337                    return getPersistence()
2338                                       .filterFindByG_P_T_PrevAndNext(plid, groupId, privateLayout,
2339                            type, orderByComparator);
2340            }
2341    
2342            /**
2343            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63; from the database.
2344            *
2345            * @param groupId the group ID
2346            * @param privateLayout the private layout
2347            * @param type the type
2348            * @throws SystemException if a system exception occurred
2349            */
2350            public static void removeByG_P_T(long groupId, boolean privateLayout,
2351                    java.lang.String type)
2352                    throws com.liferay.portal.kernel.exception.SystemException {
2353                    getPersistence().removeByG_P_T(groupId, privateLayout, type);
2354            }
2355    
2356            /**
2357            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2358            *
2359            * @param groupId the group ID
2360            * @param privateLayout the private layout
2361            * @param type the type
2362            * @return the number of matching layouts
2363            * @throws SystemException if a system exception occurred
2364            */
2365            public static int countByG_P_T(long groupId, boolean privateLayout,
2366                    java.lang.String type)
2367                    throws com.liferay.portal.kernel.exception.SystemException {
2368                    return getPersistence().countByG_P_T(groupId, privateLayout, type);
2369            }
2370    
2371            /**
2372            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2373            *
2374            * @param groupId the group ID
2375            * @param privateLayout the private layout
2376            * @param type the type
2377            * @return the number of matching layouts that the user has permission to view
2378            * @throws SystemException if a system exception occurred
2379            */
2380            public static int filterCountByG_P_T(long groupId, boolean privateLayout,
2381                    java.lang.String type)
2382                    throws com.liferay.portal.kernel.exception.SystemException {
2383                    return getPersistence().filterCountByG_P_T(groupId, privateLayout, type);
2384            }
2385    
2386            /**
2387            * 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.
2388            *
2389            * @param groupId the group ID
2390            * @param privateLayout the private layout
2391            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2392            * @return the matching layout
2393            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2394            * @throws SystemException if a system exception occurred
2395            */
2396            public static com.liferay.portal.model.Layout findByG_P_SPLU(long groupId,
2397                    boolean privateLayout, java.lang.String sourcePrototypeLayoutUuid)
2398                    throws com.liferay.portal.NoSuchLayoutException,
2399                            com.liferay.portal.kernel.exception.SystemException {
2400                    return getPersistence()
2401                                       .findByG_P_SPLU(groupId, privateLayout,
2402                            sourcePrototypeLayoutUuid);
2403            }
2404    
2405            /**
2406            * 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.
2407            *
2408            * @param groupId the group ID
2409            * @param privateLayout the private layout
2410            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2411            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2412            * @throws SystemException if a system exception occurred
2413            */
2414            public static com.liferay.portal.model.Layout fetchByG_P_SPLU(
2415                    long groupId, boolean privateLayout,
2416                    java.lang.String sourcePrototypeLayoutUuid)
2417                    throws com.liferay.portal.kernel.exception.SystemException {
2418                    return getPersistence()
2419                                       .fetchByG_P_SPLU(groupId, privateLayout,
2420                            sourcePrototypeLayoutUuid);
2421            }
2422    
2423            /**
2424            * 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.
2425            *
2426            * @param groupId the group ID
2427            * @param privateLayout the private layout
2428            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2429            * @param retrieveFromCache whether to use the finder cache
2430            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2431            * @throws SystemException if a system exception occurred
2432            */
2433            public static com.liferay.portal.model.Layout fetchByG_P_SPLU(
2434                    long groupId, boolean privateLayout,
2435                    java.lang.String sourcePrototypeLayoutUuid, boolean retrieveFromCache)
2436                    throws com.liferay.portal.kernel.exception.SystemException {
2437                    return getPersistence()
2438                                       .fetchByG_P_SPLU(groupId, privateLayout,
2439                            sourcePrototypeLayoutUuid, retrieveFromCache);
2440            }
2441    
2442            /**
2443            * Removes the layout where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63; from the database.
2444            *
2445            * @param groupId the group ID
2446            * @param privateLayout the private layout
2447            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2448            * @return the layout that was removed
2449            * @throws SystemException if a system exception occurred
2450            */
2451            public static com.liferay.portal.model.Layout removeByG_P_SPLU(
2452                    long groupId, boolean privateLayout,
2453                    java.lang.String sourcePrototypeLayoutUuid)
2454                    throws com.liferay.portal.NoSuchLayoutException,
2455                            com.liferay.portal.kernel.exception.SystemException {
2456                    return getPersistence()
2457                                       .removeByG_P_SPLU(groupId, privateLayout,
2458                            sourcePrototypeLayoutUuid);
2459            }
2460    
2461            /**
2462            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63;.
2463            *
2464            * @param groupId the group ID
2465            * @param privateLayout the private layout
2466            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2467            * @return the number of matching layouts
2468            * @throws SystemException if a system exception occurred
2469            */
2470            public static int countByG_P_SPLU(long groupId, boolean privateLayout,
2471                    java.lang.String sourcePrototypeLayoutUuid)
2472                    throws com.liferay.portal.kernel.exception.SystemException {
2473                    return getPersistence()
2474                                       .countByG_P_SPLU(groupId, privateLayout,
2475                            sourcePrototypeLayoutUuid);
2476            }
2477    
2478            /**
2479            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2480            *
2481            * @param groupId the group ID
2482            * @param privateLayout the private layout
2483            * @param parentLayoutId the parent layout ID
2484            * @param priority the priority
2485            * @return the matching layouts
2486            * @throws SystemException if a system exception occurred
2487            */
2488            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP(
2489                    long groupId, boolean privateLayout, long parentLayoutId, int priority)
2490                    throws com.liferay.portal.kernel.exception.SystemException {
2491                    return getPersistence()
2492                                       .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2493                            priority);
2494            }
2495    
2496            /**
2497            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2498            *
2499            * <p>
2500            * 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.
2501            * </p>
2502            *
2503            * @param groupId the group ID
2504            * @param privateLayout the private layout
2505            * @param parentLayoutId the parent layout ID
2506            * @param priority the priority
2507            * @param start the lower bound of the range of layouts
2508            * @param end the upper bound of the range of layouts (not inclusive)
2509            * @return the range of matching layouts
2510            * @throws SystemException if a system exception occurred
2511            */
2512            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP(
2513                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2514                    int start, int end)
2515                    throws com.liferay.portal.kernel.exception.SystemException {
2516                    return getPersistence()
2517                                       .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2518                            priority, start, end);
2519            }
2520    
2521            /**
2522            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2523            *
2524            * <p>
2525            * 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.
2526            * </p>
2527            *
2528            * @param groupId the group ID
2529            * @param privateLayout the private layout
2530            * @param parentLayoutId the parent layout ID
2531            * @param priority the priority
2532            * @param start the lower bound of the range of layouts
2533            * @param end the upper bound of the range of layouts (not inclusive)
2534            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2535            * @return the ordered range of matching layouts
2536            * @throws SystemException if a system exception occurred
2537            */
2538            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P_LtP(
2539                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2540                    int start, int end,
2541                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2542                    throws com.liferay.portal.kernel.exception.SystemException {
2543                    return getPersistence()
2544                                       .findByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2545                            priority, start, end, orderByComparator);
2546            }
2547    
2548            /**
2549            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2550            *
2551            * @param groupId the group ID
2552            * @param privateLayout the private layout
2553            * @param parentLayoutId the parent layout ID
2554            * @param priority the priority
2555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2556            * @return the first matching layout
2557            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2558            * @throws SystemException if a system exception occurred
2559            */
2560            public static com.liferay.portal.model.Layout findByG_P_P_LtP_First(
2561                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2562                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2563                    throws com.liferay.portal.NoSuchLayoutException,
2564                            com.liferay.portal.kernel.exception.SystemException {
2565                    return getPersistence()
2566                                       .findByG_P_P_LtP_First(groupId, privateLayout,
2567                            parentLayoutId, priority, orderByComparator);
2568            }
2569    
2570            /**
2571            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2572            *
2573            * @param groupId the group ID
2574            * @param privateLayout the private layout
2575            * @param parentLayoutId the parent layout ID
2576            * @param priority the priority
2577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2578            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
2579            * @throws SystemException if a system exception occurred
2580            */
2581            public static com.liferay.portal.model.Layout fetchByG_P_P_LtP_First(
2582                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2584                    throws com.liferay.portal.kernel.exception.SystemException {
2585                    return getPersistence()
2586                                       .fetchByG_P_P_LtP_First(groupId, privateLayout,
2587                            parentLayoutId, priority, orderByComparator);
2588            }
2589    
2590            /**
2591            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2592            *
2593            * @param groupId the group ID
2594            * @param privateLayout the private layout
2595            * @param parentLayoutId the parent layout ID
2596            * @param priority the priority
2597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2598            * @return the last matching layout
2599            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2600            * @throws SystemException if a system exception occurred
2601            */
2602            public static com.liferay.portal.model.Layout findByG_P_P_LtP_Last(
2603                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2605                    throws com.liferay.portal.NoSuchLayoutException,
2606                            com.liferay.portal.kernel.exception.SystemException {
2607                    return getPersistence()
2608                                       .findByG_P_P_LtP_Last(groupId, privateLayout,
2609                            parentLayoutId, priority, orderByComparator);
2610            }
2611    
2612            /**
2613            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2614            *
2615            * @param groupId the group ID
2616            * @param privateLayout the private layout
2617            * @param parentLayoutId the parent layout ID
2618            * @param priority the priority
2619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2620            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
2621            * @throws SystemException if a system exception occurred
2622            */
2623            public static com.liferay.portal.model.Layout fetchByG_P_P_LtP_Last(
2624                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2625                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2626                    throws com.liferay.portal.kernel.exception.SystemException {
2627                    return getPersistence()
2628                                       .fetchByG_P_P_LtP_Last(groupId, privateLayout,
2629                            parentLayoutId, priority, orderByComparator);
2630            }
2631    
2632            /**
2633            * 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;.
2634            *
2635            * @param plid the primary key of the current layout
2636            * @param groupId the group ID
2637            * @param privateLayout the private layout
2638            * @param parentLayoutId the parent layout ID
2639            * @param priority the priority
2640            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2641            * @return the previous, current, and next layout
2642            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2643            * @throws SystemException if a system exception occurred
2644            */
2645            public static com.liferay.portal.model.Layout[] findByG_P_P_LtP_PrevAndNext(
2646                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2647                    int priority,
2648                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2649                    throws com.liferay.portal.NoSuchLayoutException,
2650                            com.liferay.portal.kernel.exception.SystemException {
2651                    return getPersistence()
2652                                       .findByG_P_P_LtP_PrevAndNext(plid, groupId, privateLayout,
2653                            parentLayoutId, priority, orderByComparator);
2654            }
2655    
2656            /**
2657            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2658            *
2659            * @param groupId the group ID
2660            * @param privateLayout the private layout
2661            * @param parentLayoutId the parent layout ID
2662            * @param priority the priority
2663            * @return the matching layouts that the user has permission to view
2664            * @throws SystemException if a system exception occurred
2665            */
2666            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP(
2667                    long groupId, boolean privateLayout, long parentLayoutId, int priority)
2668                    throws com.liferay.portal.kernel.exception.SystemException {
2669                    return getPersistence()
2670                                       .filterFindByG_P_P_LtP(groupId, privateLayout,
2671                            parentLayoutId, priority);
2672            }
2673    
2674            /**
2675            * 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;.
2676            *
2677            * <p>
2678            * 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.
2679            * </p>
2680            *
2681            * @param groupId the group ID
2682            * @param privateLayout the private layout
2683            * @param parentLayoutId the parent layout ID
2684            * @param priority the priority
2685            * @param start the lower bound of the range of layouts
2686            * @param end the upper bound of the range of layouts (not inclusive)
2687            * @return the range of matching layouts that the user has permission to view
2688            * @throws SystemException if a system exception occurred
2689            */
2690            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP(
2691                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2692                    int start, int end)
2693                    throws com.liferay.portal.kernel.exception.SystemException {
2694                    return getPersistence()
2695                                       .filterFindByG_P_P_LtP(groupId, privateLayout,
2696                            parentLayoutId, priority, start, end);
2697            }
2698    
2699            /**
2700            * 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;.
2701            *
2702            * <p>
2703            * 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.
2704            * </p>
2705            *
2706            * @param groupId the group ID
2707            * @param privateLayout the private layout
2708            * @param parentLayoutId the parent layout ID
2709            * @param priority the priority
2710            * @param start the lower bound of the range of layouts
2711            * @param end the upper bound of the range of layouts (not inclusive)
2712            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2713            * @return the ordered range of matching layouts that the user has permission to view
2714            * @throws SystemException if a system exception occurred
2715            */
2716            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P_LtP(
2717                    long groupId, boolean privateLayout, long parentLayoutId, int priority,
2718                    int start, int end,
2719                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2720                    throws com.liferay.portal.kernel.exception.SystemException {
2721                    return getPersistence()
2722                                       .filterFindByG_P_P_LtP(groupId, privateLayout,
2723                            parentLayoutId, priority, start, end, orderByComparator);
2724            }
2725    
2726            /**
2727            * 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;.
2728            *
2729            * @param plid the primary key of the current layout
2730            * @param groupId the group ID
2731            * @param privateLayout the private layout
2732            * @param parentLayoutId the parent layout ID
2733            * @param priority the priority
2734            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2735            * @return the previous, current, and next layout
2736            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2737            * @throws SystemException if a system exception occurred
2738            */
2739            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_LtP_PrevAndNext(
2740                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
2741                    int priority,
2742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2743                    throws com.liferay.portal.NoSuchLayoutException,
2744                            com.liferay.portal.kernel.exception.SystemException {
2745                    return getPersistence()
2746                                       .filterFindByG_P_P_LtP_PrevAndNext(plid, groupId,
2747                            privateLayout, parentLayoutId, priority, orderByComparator);
2748            }
2749    
2750            /**
2751            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63; from the database.
2752            *
2753            * @param groupId the group ID
2754            * @param privateLayout the private layout
2755            * @param parentLayoutId the parent layout ID
2756            * @param priority the priority
2757            * @throws SystemException if a system exception occurred
2758            */
2759            public static void removeByG_P_P_LtP(long groupId, boolean privateLayout,
2760                    long parentLayoutId, int priority)
2761                    throws com.liferay.portal.kernel.exception.SystemException {
2762                    getPersistence()
2763                            .removeByG_P_P_LtP(groupId, privateLayout, parentLayoutId, priority);
2764            }
2765    
2766            /**
2767            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; and priority &le; &#63;.
2768            *
2769            * @param groupId the group ID
2770            * @param privateLayout the private layout
2771            * @param parentLayoutId the parent layout ID
2772            * @param priority the priority
2773            * @return the number of matching layouts
2774            * @throws SystemException if a system exception occurred
2775            */
2776            public static int countByG_P_P_LtP(long groupId, boolean privateLayout,
2777                    long parentLayoutId, int priority)
2778                    throws com.liferay.portal.kernel.exception.SystemException {
2779                    return getPersistence()
2780                                       .countByG_P_P_LtP(groupId, privateLayout, parentLayoutId,
2781                            priority);
2782            }
2783    
2784            /**
2785            * 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;.
2786            *
2787            * @param groupId the group ID
2788            * @param privateLayout the private layout
2789            * @param parentLayoutId the parent layout ID
2790            * @param priority the priority
2791            * @return the number of matching layouts that the user has permission to view
2792            * @throws SystemException if a system exception occurred
2793            */
2794            public static int filterCountByG_P_P_LtP(long groupId,
2795                    boolean privateLayout, long parentLayoutId, int priority)
2796                    throws com.liferay.portal.kernel.exception.SystemException {
2797                    return getPersistence()
2798                                       .filterCountByG_P_P_LtP(groupId, privateLayout,
2799                            parentLayoutId, priority);
2800            }
2801    
2802            /**
2803            * Caches the layout in the entity cache if it is enabled.
2804            *
2805            * @param layout the layout
2806            */
2807            public static void cacheResult(com.liferay.portal.model.Layout layout) {
2808                    getPersistence().cacheResult(layout);
2809            }
2810    
2811            /**
2812            * Caches the layouts in the entity cache if it is enabled.
2813            *
2814            * @param layouts the layouts
2815            */
2816            public static void cacheResult(
2817                    java.util.List<com.liferay.portal.model.Layout> layouts) {
2818                    getPersistence().cacheResult(layouts);
2819            }
2820    
2821            /**
2822            * Creates a new layout with the primary key. Does not add the layout to the database.
2823            *
2824            * @param plid the primary key for the new layout
2825            * @return the new layout
2826            */
2827            public static com.liferay.portal.model.Layout create(long plid) {
2828                    return getPersistence().create(plid);
2829            }
2830    
2831            /**
2832            * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners.
2833            *
2834            * @param plid the primary key of the layout
2835            * @return the layout that was removed
2836            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2837            * @throws SystemException if a system exception occurred
2838            */
2839            public static com.liferay.portal.model.Layout remove(long plid)
2840                    throws com.liferay.portal.NoSuchLayoutException,
2841                            com.liferay.portal.kernel.exception.SystemException {
2842                    return getPersistence().remove(plid);
2843            }
2844    
2845            public static com.liferay.portal.model.Layout updateImpl(
2846                    com.liferay.portal.model.Layout layout)
2847                    throws com.liferay.portal.kernel.exception.SystemException {
2848                    return getPersistence().updateImpl(layout);
2849            }
2850    
2851            /**
2852            * Returns the layout with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
2853            *
2854            * @param plid the primary key of the layout
2855            * @return the layout
2856            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2857            * @throws SystemException if a system exception occurred
2858            */
2859            public static com.liferay.portal.model.Layout findByPrimaryKey(long plid)
2860                    throws com.liferay.portal.NoSuchLayoutException,
2861                            com.liferay.portal.kernel.exception.SystemException {
2862                    return getPersistence().findByPrimaryKey(plid);
2863            }
2864    
2865            /**
2866            * Returns the layout with the primary key or returns <code>null</code> if it could not be found.
2867            *
2868            * @param plid the primary key of the layout
2869            * @return the layout, or <code>null</code> if a layout with the primary key could not be found
2870            * @throws SystemException if a system exception occurred
2871            */
2872            public static com.liferay.portal.model.Layout fetchByPrimaryKey(long plid)
2873                    throws com.liferay.portal.kernel.exception.SystemException {
2874                    return getPersistence().fetchByPrimaryKey(plid);
2875            }
2876    
2877            /**
2878            * Returns all the layouts.
2879            *
2880            * @return the layouts
2881            * @throws SystemException if a system exception occurred
2882            */
2883            public static java.util.List<com.liferay.portal.model.Layout> findAll()
2884                    throws com.liferay.portal.kernel.exception.SystemException {
2885                    return getPersistence().findAll();
2886            }
2887    
2888            /**
2889            * Returns a range of all the layouts.
2890            *
2891            * <p>
2892            * 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.
2893            * </p>
2894            *
2895            * @param start the lower bound of the range of layouts
2896            * @param end the upper bound of the range of layouts (not inclusive)
2897            * @return the range of layouts
2898            * @throws SystemException if a system exception occurred
2899            */
2900            public static java.util.List<com.liferay.portal.model.Layout> findAll(
2901                    int start, int end)
2902                    throws com.liferay.portal.kernel.exception.SystemException {
2903                    return getPersistence().findAll(start, end);
2904            }
2905    
2906            /**
2907            * Returns an ordered range of all the layouts.
2908            *
2909            * <p>
2910            * 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.
2911            * </p>
2912            *
2913            * @param start the lower bound of the range of layouts
2914            * @param end the upper bound of the range of layouts (not inclusive)
2915            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2916            * @return the ordered range of layouts
2917            * @throws SystemException if a system exception occurred
2918            */
2919            public static java.util.List<com.liferay.portal.model.Layout> findAll(
2920                    int start, int end,
2921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2922                    throws com.liferay.portal.kernel.exception.SystemException {
2923                    return getPersistence().findAll(start, end, orderByComparator);
2924            }
2925    
2926            /**
2927            * Removes all the layouts from the database.
2928            *
2929            * @throws SystemException if a system exception occurred
2930            */
2931            public static void removeAll()
2932                    throws com.liferay.portal.kernel.exception.SystemException {
2933                    getPersistence().removeAll();
2934            }
2935    
2936            /**
2937            * Returns the number of layouts.
2938            *
2939            * @return the number of layouts
2940            * @throws SystemException if a system exception occurred
2941            */
2942            public static int countAll()
2943                    throws com.liferay.portal.kernel.exception.SystemException {
2944                    return getPersistence().countAll();
2945            }
2946    
2947            public static LayoutPersistence getPersistence() {
2948                    if (_persistence == null) {
2949                            _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName());
2950    
2951                            ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence");
2952                    }
2953    
2954                    return _persistence;
2955            }
2956    
2957            /**
2958             * @deprecated As of 6.2.0
2959             */
2960            public void setPersistence(LayoutPersistence persistence) {
2961            }
2962    
2963            private static LayoutPersistence _persistence;
2964    }