001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import 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 all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1711            *
1712            * @param groupId the group ID
1713            * @param privateLayout the private layout
1714            * @param parentLayoutId the parent layout ID
1715            * @return the matching layouts
1716            * @throws SystemException if a system exception occurred
1717            */
1718            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1719                    long groupId, boolean privateLayout, long parentLayoutId)
1720                    throws com.liferay.portal.kernel.exception.SystemException {
1721                    return getPersistence()
1722                                       .findByG_P_P(groupId, privateLayout, parentLayoutId);
1723            }
1724    
1725            /**
1726            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1727            *
1728            * <p>
1729            * 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.
1730            * </p>
1731            *
1732            * @param groupId the group ID
1733            * @param privateLayout the private layout
1734            * @param parentLayoutId the parent layout ID
1735            * @param start the lower bound of the range of layouts
1736            * @param end the upper bound of the range of layouts (not inclusive)
1737            * @return the range of matching layouts
1738            * @throws SystemException if a system exception occurred
1739            */
1740            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1741                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1742                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1743                    return getPersistence()
1744                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1745                            end);
1746            }
1747    
1748            /**
1749            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1750            *
1751            * <p>
1752            * 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.
1753            * </p>
1754            *
1755            * @param groupId the group ID
1756            * @param privateLayout the private layout
1757            * @param parentLayoutId the parent layout ID
1758            * @param start the lower bound of the range of layouts
1759            * @param end the upper bound of the range of layouts (not inclusive)
1760            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1761            * @return the ordered range of matching layouts
1762            * @throws SystemException if a system exception occurred
1763            */
1764            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1765                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1766                    int end,
1767                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1768                    throws com.liferay.portal.kernel.exception.SystemException {
1769                    return getPersistence()
1770                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1771                            end, orderByComparator);
1772            }
1773    
1774            /**
1775            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1776            *
1777            * @param groupId the group ID
1778            * @param privateLayout the private layout
1779            * @param parentLayoutId the parent layout ID
1780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1781            * @return the first matching layout
1782            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1783            * @throws SystemException if a system exception occurred
1784            */
1785            public static com.liferay.portal.model.Layout findByG_P_P_First(
1786                    long groupId, boolean privateLayout, long parentLayoutId,
1787                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1788                    throws com.liferay.portal.NoSuchLayoutException,
1789                            com.liferay.portal.kernel.exception.SystemException {
1790                    return getPersistence()
1791                                       .findByG_P_P_First(groupId, privateLayout, parentLayoutId,
1792                            orderByComparator);
1793            }
1794    
1795            /**
1796            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1797            *
1798            * @param groupId the group ID
1799            * @param privateLayout the private layout
1800            * @param parentLayoutId the parent layout ID
1801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1802            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1803            * @throws SystemException if a system exception occurred
1804            */
1805            public static com.liferay.portal.model.Layout fetchByG_P_P_First(
1806                    long groupId, boolean privateLayout, long parentLayoutId,
1807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1808                    throws com.liferay.portal.kernel.exception.SystemException {
1809                    return getPersistence()
1810                                       .fetchByG_P_P_First(groupId, privateLayout, parentLayoutId,
1811                            orderByComparator);
1812            }
1813    
1814            /**
1815            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1816            *
1817            * @param groupId the group ID
1818            * @param privateLayout the private layout
1819            * @param parentLayoutId the parent layout ID
1820            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1821            * @return the last matching layout
1822            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1823            * @throws SystemException if a system exception occurred
1824            */
1825            public static com.liferay.portal.model.Layout findByG_P_P_Last(
1826                    long groupId, boolean privateLayout, long parentLayoutId,
1827                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1828                    throws com.liferay.portal.NoSuchLayoutException,
1829                            com.liferay.portal.kernel.exception.SystemException {
1830                    return getPersistence()
1831                                       .findByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1832                            orderByComparator);
1833            }
1834    
1835            /**
1836            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1837            *
1838            * @param groupId the group ID
1839            * @param privateLayout the private layout
1840            * @param parentLayoutId the parent layout ID
1841            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1842            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1843            * @throws SystemException if a system exception occurred
1844            */
1845            public static com.liferay.portal.model.Layout fetchByG_P_P_Last(
1846                    long groupId, boolean privateLayout, long parentLayoutId,
1847                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1848                    throws com.liferay.portal.kernel.exception.SystemException {
1849                    return getPersistence()
1850                                       .fetchByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1851                            orderByComparator);
1852            }
1853    
1854            /**
1855            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1856            *
1857            * @param plid the primary key of the current layout
1858            * @param groupId the group ID
1859            * @param privateLayout the private layout
1860            * @param parentLayoutId the parent layout ID
1861            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1862            * @return the previous, current, and next layout
1863            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1864            * @throws SystemException if a system exception occurred
1865            */
1866            public static com.liferay.portal.model.Layout[] findByG_P_P_PrevAndNext(
1867                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1868                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1869                    throws com.liferay.portal.NoSuchLayoutException,
1870                            com.liferay.portal.kernel.exception.SystemException {
1871                    return getPersistence()
1872                                       .findByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1873                            parentLayoutId, orderByComparator);
1874            }
1875    
1876            /**
1877            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1878            *
1879            * @param groupId the group ID
1880            * @param privateLayout the private layout
1881            * @param parentLayoutId the parent layout ID
1882            * @return the matching layouts that the user has permission to view
1883            * @throws SystemException if a system exception occurred
1884            */
1885            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1886                    long groupId, boolean privateLayout, long parentLayoutId)
1887                    throws com.liferay.portal.kernel.exception.SystemException {
1888                    return getPersistence()
1889                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId);
1890            }
1891    
1892            /**
1893            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1894            *
1895            * <p>
1896            * 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.
1897            * </p>
1898            *
1899            * @param groupId the group ID
1900            * @param privateLayout the private layout
1901            * @param parentLayoutId the parent layout ID
1902            * @param start the lower bound of the range of layouts
1903            * @param end the upper bound of the range of layouts (not inclusive)
1904            * @return the range of matching layouts that the user has permission to view
1905            * @throws SystemException if a system exception occurred
1906            */
1907            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1908                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1909                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1910                    return getPersistence()
1911                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1912                            start, end);
1913            }
1914    
1915            /**
1916            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1917            *
1918            * <p>
1919            * 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.
1920            * </p>
1921            *
1922            * @param groupId the group ID
1923            * @param privateLayout the private layout
1924            * @param parentLayoutId the parent layout ID
1925            * @param start the lower bound of the range of layouts
1926            * @param end the upper bound of the range of layouts (not inclusive)
1927            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1928            * @return the ordered range of matching layouts that the user has permission to view
1929            * @throws SystemException if a system exception occurred
1930            */
1931            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1932                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1933                    int end,
1934                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1935                    throws com.liferay.portal.kernel.exception.SystemException {
1936                    return getPersistence()
1937                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1938                            start, end, orderByComparator);
1939            }
1940    
1941            /**
1942            * 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;.
1943            *
1944            * @param plid the primary key of the current layout
1945            * @param groupId the group ID
1946            * @param privateLayout the private layout
1947            * @param parentLayoutId the parent layout ID
1948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1949            * @return the previous, current, and next layout
1950            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1951            * @throws SystemException if a system exception occurred
1952            */
1953            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_PrevAndNext(
1954                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1955                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1956                    throws com.liferay.portal.NoSuchLayoutException,
1957                            com.liferay.portal.kernel.exception.SystemException {
1958                    return getPersistence()
1959                                       .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1960                            parentLayoutId, orderByComparator);
1961            }
1962    
1963            /**
1964            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; from the database.
1965            *
1966            * @param groupId the group ID
1967            * @param privateLayout the private layout
1968            * @param parentLayoutId the parent layout ID
1969            * @throws SystemException if a system exception occurred
1970            */
1971            public static void removeByG_P_P(long groupId, boolean privateLayout,
1972                    long parentLayoutId)
1973                    throws com.liferay.portal.kernel.exception.SystemException {
1974                    getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId);
1975            }
1976    
1977            /**
1978            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1979            *
1980            * @param groupId the group ID
1981            * @param privateLayout the private layout
1982            * @param parentLayoutId the parent layout ID
1983            * @return the number of matching layouts
1984            * @throws SystemException if a system exception occurred
1985            */
1986            public static int countByG_P_P(long groupId, boolean privateLayout,
1987                    long parentLayoutId)
1988                    throws com.liferay.portal.kernel.exception.SystemException {
1989                    return getPersistence()
1990                                       .countByG_P_P(groupId, privateLayout, parentLayoutId);
1991            }
1992    
1993            /**
1994            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1995            *
1996            * @param groupId the group ID
1997            * @param privateLayout the private layout
1998            * @param parentLayoutId the parent layout ID
1999            * @return the number of matching layouts that the user has permission to view
2000            * @throws SystemException if a system exception occurred
2001            */
2002            public static int filterCountByG_P_P(long groupId, boolean privateLayout,
2003                    long parentLayoutId)
2004                    throws com.liferay.portal.kernel.exception.SystemException {
2005                    return getPersistence()
2006                                       .filterCountByG_P_P(groupId, privateLayout, parentLayoutId);
2007            }
2008    
2009            /**
2010            * 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.
2011            *
2012            * @param groupId the group ID
2013            * @param privateLayout the private layout
2014            * @param friendlyURL the friendly u r l
2015            * @return the matching layout
2016            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
2017            * @throws SystemException if a system exception occurred
2018            */
2019            public static com.liferay.portal.model.Layout findByG_P_F(long groupId,
2020                    boolean privateLayout, java.lang.String friendlyURL)
2021                    throws com.liferay.portal.NoSuchLayoutException,
2022                            com.liferay.portal.kernel.exception.SystemException {
2023                    return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL);
2024            }
2025    
2026            /**
2027            * 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.
2028            *
2029            * @param groupId the group ID
2030            * @param privateLayout the private layout
2031            * @param friendlyURL the friendly u r l
2032            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2033            * @throws SystemException if a system exception occurred
2034            */
2035            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
2036                    boolean privateLayout, java.lang.String friendlyURL)
2037                    throws com.liferay.portal.kernel.exception.SystemException {
2038                    return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL);
2039            }
2040    
2041            /**
2042            * 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.
2043            *
2044            * @param groupId the group ID
2045            * @param privateLayout the private layout
2046            * @param friendlyURL the friendly u r l
2047            * @param retrieveFromCache whether to use the finder cache
2048            * @return the matching layout, or <code>null</code> if a matching layout could not be found
2049            * @throws SystemException if a system exception occurred
2050            */
2051            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
2052                    boolean privateLayout, java.lang.String friendlyURL,
2053                    boolean retrieveFromCache)
2054                    throws com.liferay.portal.kernel.exception.SystemException {
2055                    return getPersistence()
2056                                       .fetchByG_P_F(groupId, privateLayout, friendlyURL,
2057                            retrieveFromCache);
2058            }
2059    
2060            /**
2061            * Removes the layout where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; from the database.
2062            *
2063            * @param groupId the group ID
2064            * @param privateLayout the private layout
2065            * @param friendlyURL the friendly u r l
2066            * @return the layout that was removed
2067            * @throws SystemException if a system exception occurred
2068            */
2069            public static com.liferay.portal.model.Layout removeByG_P_F(long groupId,
2070                    boolean privateLayout, java.lang.String friendlyURL)
2071                    throws com.liferay.portal.NoSuchLayoutException,
2072                            com.liferay.portal.kernel.exception.SystemException {
2073                    return getPersistence()
2074                                       .removeByG_P_F(groupId, privateLayout, friendlyURL);
2075            }
2076    
2077            /**
2078            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
2079            *
2080            * @param groupId the group ID
2081            * @param privateLayout the private layout
2082            * @param friendlyURL the friendly u r l
2083            * @return the number of matching layouts
2084            * @throws SystemException if a system exception occurred
2085            */
2086            public static int countByG_P_F(long groupId, boolean privateLayout,
2087                    java.lang.String friendlyURL)
2088                    throws com.liferay.portal.kernel.exception.SystemException {
2089                    return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL);
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            * Caches the layout in the entity cache if it is enabled.
2480            *
2481            * @param layout the layout
2482            */
2483            public static void cacheResult(com.liferay.portal.model.Layout layout) {
2484                    getPersistence().cacheResult(layout);
2485            }
2486    
2487            /**
2488            * Caches the layouts in the entity cache if it is enabled.
2489            *
2490            * @param layouts the layouts
2491            */
2492            public static void cacheResult(
2493                    java.util.List<com.liferay.portal.model.Layout> layouts) {
2494                    getPersistence().cacheResult(layouts);
2495            }
2496    
2497            /**
2498            * Creates a new layout with the primary key. Does not add the layout to the database.
2499            *
2500            * @param plid the primary key for the new layout
2501            * @return the new layout
2502            */
2503            public static com.liferay.portal.model.Layout create(long plid) {
2504                    return getPersistence().create(plid);
2505            }
2506    
2507            /**
2508            * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners.
2509            *
2510            * @param plid the primary key of the layout
2511            * @return the layout that was removed
2512            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2513            * @throws SystemException if a system exception occurred
2514            */
2515            public static com.liferay.portal.model.Layout remove(long plid)
2516                    throws com.liferay.portal.NoSuchLayoutException,
2517                            com.liferay.portal.kernel.exception.SystemException {
2518                    return getPersistence().remove(plid);
2519            }
2520    
2521            public static com.liferay.portal.model.Layout updateImpl(
2522                    com.liferay.portal.model.Layout layout)
2523                    throws com.liferay.portal.kernel.exception.SystemException {
2524                    return getPersistence().updateImpl(layout);
2525            }
2526    
2527            /**
2528            * Returns the layout with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
2529            *
2530            * @param plid the primary key of the layout
2531            * @return the layout
2532            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
2533            * @throws SystemException if a system exception occurred
2534            */
2535            public static com.liferay.portal.model.Layout findByPrimaryKey(long plid)
2536                    throws com.liferay.portal.NoSuchLayoutException,
2537                            com.liferay.portal.kernel.exception.SystemException {
2538                    return getPersistence().findByPrimaryKey(plid);
2539            }
2540    
2541            /**
2542            * Returns the layout with the primary key or returns <code>null</code> if it could not be found.
2543            *
2544            * @param plid the primary key of the layout
2545            * @return the layout, or <code>null</code> if a layout with the primary key could not be found
2546            * @throws SystemException if a system exception occurred
2547            */
2548            public static com.liferay.portal.model.Layout fetchByPrimaryKey(long plid)
2549                    throws com.liferay.portal.kernel.exception.SystemException {
2550                    return getPersistence().fetchByPrimaryKey(plid);
2551            }
2552    
2553            /**
2554            * Returns all the layouts.
2555            *
2556            * @return the layouts
2557            * @throws SystemException if a system exception occurred
2558            */
2559            public static java.util.List<com.liferay.portal.model.Layout> findAll()
2560                    throws com.liferay.portal.kernel.exception.SystemException {
2561                    return getPersistence().findAll();
2562            }
2563    
2564            /**
2565            * Returns a range of all the layouts.
2566            *
2567            * <p>
2568            * 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.
2569            * </p>
2570            *
2571            * @param start the lower bound of the range of layouts
2572            * @param end the upper bound of the range of layouts (not inclusive)
2573            * @return the range of layouts
2574            * @throws SystemException if a system exception occurred
2575            */
2576            public static java.util.List<com.liferay.portal.model.Layout> findAll(
2577                    int start, int end)
2578                    throws com.liferay.portal.kernel.exception.SystemException {
2579                    return getPersistence().findAll(start, end);
2580            }
2581    
2582            /**
2583            * Returns an ordered range of all the layouts.
2584            *
2585            * <p>
2586            * 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.
2587            * </p>
2588            *
2589            * @param start the lower bound of the range of layouts
2590            * @param end the upper bound of the range of layouts (not inclusive)
2591            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2592            * @return the ordered range of layouts
2593            * @throws SystemException if a system exception occurred
2594            */
2595            public static java.util.List<com.liferay.portal.model.Layout> findAll(
2596                    int start, int end,
2597                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2598                    throws com.liferay.portal.kernel.exception.SystemException {
2599                    return getPersistence().findAll(start, end, orderByComparator);
2600            }
2601    
2602            /**
2603            * Removes all the layouts from the database.
2604            *
2605            * @throws SystemException if a system exception occurred
2606            */
2607            public static void removeAll()
2608                    throws com.liferay.portal.kernel.exception.SystemException {
2609                    getPersistence().removeAll();
2610            }
2611    
2612            /**
2613            * Returns the number of layouts.
2614            *
2615            * @return the number of layouts
2616            * @throws SystemException if a system exception occurred
2617            */
2618            public static int countAll()
2619                    throws com.liferay.portal.kernel.exception.SystemException {
2620                    return getPersistence().countAll();
2621            }
2622    
2623            public static LayoutPersistence getPersistence() {
2624                    if (_persistence == null) {
2625                            _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName());
2626    
2627                            ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence");
2628                    }
2629    
2630                    return _persistence;
2631            }
2632    
2633            /**
2634             * @deprecated As of 6.2.0
2635             */
2636            public void setPersistence(LayoutPersistence persistence) {
2637            }
2638    
2639            private static LayoutPersistence _persistence;
2640    }