001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.model.Layout;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the layout service. This utility wraps {@link LayoutPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
029     *
030     * <p>
031     * Caching information and settings can be found in <code>portal.properties</code>
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see LayoutPersistence
036     * @see LayoutPersistenceImpl
037     * @generated
038     */
039    public class LayoutUtil {
040            /*
041             * NOTE FOR DEVELOPERS:
042             *
043             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
044             */
045    
046            /**
047             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
048             */
049            public static void clearCache() {
050                    getPersistence().clearCache();
051            }
052    
053            /**
054             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
055             */
056            public static void clearCache(Layout layout) {
057                    getPersistence().clearCache(layout);
058            }
059    
060            /**
061             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
062             */
063            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
064                    throws SystemException {
065                    return getPersistence().countWithDynamicQuery(dynamicQuery);
066            }
067    
068            /**
069             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
070             */
071            public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery)
072                    throws SystemException {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
078             */
079            public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery,
080                    int start, int end) throws SystemException {
081                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
082            }
083    
084            /**
085             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
086             */
087            public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery,
088                    int start, int end, OrderByComparator orderByComparator)
089                    throws SystemException {
090                    return getPersistence()
091                                       .findWithDynamicQuery(dynamicQuery, start, end,
092                            orderByComparator);
093            }
094    
095            /**
096             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
097             */
098            public static Layout remove(Layout layout) throws SystemException {
099                    return getPersistence().remove(layout);
100            }
101    
102            /**
103             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
104             */
105            public static Layout update(Layout layout, boolean merge)
106                    throws SystemException {
107                    return getPersistence().update(layout, merge);
108            }
109    
110            /**
111             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
112             */
113            public static Layout update(Layout layout, boolean merge,
114                    ServiceContext serviceContext) throws SystemException {
115                    return getPersistence().update(layout, merge, serviceContext);
116            }
117    
118            /**
119            * Caches the layout in the entity cache if it is enabled.
120            *
121            * @param layout the layout to cache
122            */
123            public static void cacheResult(com.liferay.portal.model.Layout layout) {
124                    getPersistence().cacheResult(layout);
125            }
126    
127            /**
128            * Caches the layouts in the entity cache if it is enabled.
129            *
130            * @param layouts the layouts to cache
131            */
132            public static void cacheResult(
133                    java.util.List<com.liferay.portal.model.Layout> layouts) {
134                    getPersistence().cacheResult(layouts);
135            }
136    
137            /**
138            * Creates a new layout with the primary key. Does not add the layout to the database.
139            *
140            * @param plid the primary key for the new layout
141            * @return the new layout
142            */
143            public static com.liferay.portal.model.Layout create(long plid) {
144                    return getPersistence().create(plid);
145            }
146    
147            /**
148            * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners.
149            *
150            * @param plid the primary key of the layout to remove
151            * @return the layout that was removed
152            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
153            * @throws SystemException if a system exception occurred
154            */
155            public static com.liferay.portal.model.Layout remove(long plid)
156                    throws com.liferay.portal.NoSuchLayoutException,
157                            com.liferay.portal.kernel.exception.SystemException {
158                    return getPersistence().remove(plid);
159            }
160    
161            public static com.liferay.portal.model.Layout updateImpl(
162                    com.liferay.portal.model.Layout layout, boolean merge)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence().updateImpl(layout, merge);
165            }
166    
167            /**
168            * Finds the layout with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
169            *
170            * @param plid the primary key of the layout to find
171            * @return the layout
172            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portal.model.Layout findByPrimaryKey(long plid)
176                    throws com.liferay.portal.NoSuchLayoutException,
177                            com.liferay.portal.kernel.exception.SystemException {
178                    return getPersistence().findByPrimaryKey(plid);
179            }
180    
181            /**
182            * Finds the layout with the primary key or returns <code>null</code> if it could not be found.
183            *
184            * @param plid the primary key of the layout to find
185            * @return the layout, or <code>null</code> if a layout with the primary key could not be found
186            * @throws SystemException if a system exception occurred
187            */
188            public static com.liferay.portal.model.Layout fetchByPrimaryKey(long plid)
189                    throws com.liferay.portal.kernel.exception.SystemException {
190                    return getPersistence().fetchByPrimaryKey(plid);
191            }
192    
193            /**
194            * Finds all the layouts where uuid = &#63;.
195            *
196            * @param uuid the uuid to search with
197            * @return the matching layouts
198            * @throws SystemException if a system exception occurred
199            */
200            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
201                    java.lang.String uuid)
202                    throws com.liferay.portal.kernel.exception.SystemException {
203                    return getPersistence().findByUuid(uuid);
204            }
205    
206            /**
207            * Finds a range of all the layouts where uuid = &#63;.
208            *
209            * <p>
210            * 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.
211            * </p>
212            *
213            * @param uuid the uuid to search with
214            * @param start the lower bound of the range of layouts to return
215            * @param end the upper bound of the range of layouts to return (not inclusive)
216            * @return the range of matching layouts
217            * @throws SystemException if a system exception occurred
218            */
219            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
220                    java.lang.String uuid, int start, int end)
221                    throws com.liferay.portal.kernel.exception.SystemException {
222                    return getPersistence().findByUuid(uuid, start, end);
223            }
224    
225            /**
226            * Finds an ordered range of all the layouts where uuid = &#63;.
227            *
228            * <p>
229            * 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.
230            * </p>
231            *
232            * @param uuid the uuid to search with
233            * @param start the lower bound of the range of layouts to return
234            * @param end the upper bound of the range of layouts to return (not inclusive)
235            * @param orderByComparator the comparator to order the results by
236            * @return the ordered range of matching layouts
237            * @throws SystemException if a system exception occurred
238            */
239            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
240                    java.lang.String uuid, int start, int end,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.kernel.exception.SystemException {
243                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
244            }
245    
246            /**
247            * Finds the first layout in the ordered set where uuid = &#63;.
248            *
249            * <p>
250            * 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.
251            * </p>
252            *
253            * @param uuid the uuid to search with
254            * @param orderByComparator the comparator to order the set by
255            * @return the first matching layout
256            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
257            * @throws SystemException if a system exception occurred
258            */
259            public static com.liferay.portal.model.Layout findByUuid_First(
260                    java.lang.String uuid,
261                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
262                    throws com.liferay.portal.NoSuchLayoutException,
263                            com.liferay.portal.kernel.exception.SystemException {
264                    return getPersistence().findByUuid_First(uuid, orderByComparator);
265            }
266    
267            /**
268            * Finds the last layout in the ordered set where uuid = &#63;.
269            *
270            * <p>
271            * 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.
272            * </p>
273            *
274            * @param uuid the uuid to search with
275            * @param orderByComparator the comparator to order the set by
276            * @return the last matching layout
277            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
278            * @throws SystemException if a system exception occurred
279            */
280            public static com.liferay.portal.model.Layout findByUuid_Last(
281                    java.lang.String uuid,
282                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
283                    throws com.liferay.portal.NoSuchLayoutException,
284                            com.liferay.portal.kernel.exception.SystemException {
285                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
286            }
287    
288            /**
289            * Finds the layouts before and after the current layout in the ordered set where uuid = &#63;.
290            *
291            * <p>
292            * 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.
293            * </p>
294            *
295            * @param plid the primary key of the current layout
296            * @param uuid the uuid to search with
297            * @param orderByComparator the comparator to order the set by
298            * @return the previous, current, and next layout
299            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
300            * @throws SystemException if a system exception occurred
301            */
302            public static com.liferay.portal.model.Layout[] findByUuid_PrevAndNext(
303                    long plid, java.lang.String uuid,
304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
305                    throws com.liferay.portal.NoSuchLayoutException,
306                            com.liferay.portal.kernel.exception.SystemException {
307                    return getPersistence()
308                                       .findByUuid_PrevAndNext(plid, uuid, orderByComparator);
309            }
310    
311            /**
312            * Finds the layout where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
313            *
314            * @param uuid the uuid to search with
315            * @param groupId the group ID to search with
316            * @return the matching layout
317            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
318            * @throws SystemException if a system exception occurred
319            */
320            public static com.liferay.portal.model.Layout findByUUID_G(
321                    java.lang.String uuid, long groupId)
322                    throws com.liferay.portal.NoSuchLayoutException,
323                            com.liferay.portal.kernel.exception.SystemException {
324                    return getPersistence().findByUUID_G(uuid, groupId);
325            }
326    
327            /**
328            * Finds the layout where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
329            *
330            * @param uuid the uuid to search with
331            * @param groupId the group ID to search with
332            * @return the matching layout, or <code>null</code> if a matching layout could not be found
333            * @throws SystemException if a system exception occurred
334            */
335            public static com.liferay.portal.model.Layout fetchByUUID_G(
336                    java.lang.String uuid, long groupId)
337                    throws com.liferay.portal.kernel.exception.SystemException {
338                    return getPersistence().fetchByUUID_G(uuid, groupId);
339            }
340    
341            /**
342            * Finds the layout where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
343            *
344            * @param uuid the uuid to search with
345            * @param groupId the group ID to search with
346            * @return the matching layout, or <code>null</code> if a matching layout could not be found
347            * @throws SystemException if a system exception occurred
348            */
349            public static com.liferay.portal.model.Layout fetchByUUID_G(
350                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
351                    throws com.liferay.portal.kernel.exception.SystemException {
352                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
353            }
354    
355            /**
356            * Finds all the layouts where groupId = &#63;.
357            *
358            * @param groupId the group ID to search with
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> findByGroupId(
363                    long groupId)
364                    throws com.liferay.portal.kernel.exception.SystemException {
365                    return getPersistence().findByGroupId(groupId);
366            }
367    
368            /**
369            * Finds a range of all the layouts where groupId = &#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.
373            * </p>
374            *
375            * @param groupId the group ID to search with
376            * @param start the lower bound of the range of layouts to return
377            * @param end the upper bound of the range of layouts to return (not inclusive)
378            * @return the range of matching layouts
379            * @throws SystemException if a system exception occurred
380            */
381            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
382                    long groupId, int start, int end)
383                    throws com.liferay.portal.kernel.exception.SystemException {
384                    return getPersistence().findByGroupId(groupId, start, end);
385            }
386    
387            /**
388            * Finds an ordered range of all the layouts where groupId = &#63;.
389            *
390            * <p>
391            * 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.
392            * </p>
393            *
394            * @param groupId the group ID to search with
395            * @param start the lower bound of the range of layouts to return
396            * @param end the upper bound of the range of layouts to return (not inclusive)
397            * @param orderByComparator the comparator to order the results by
398            * @return the ordered range of matching layouts
399            * @throws SystemException if a system exception occurred
400            */
401            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
402                    long groupId, int start, int end,
403                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
404                    throws com.liferay.portal.kernel.exception.SystemException {
405                    return getPersistence()
406                                       .findByGroupId(groupId, start, end, orderByComparator);
407            }
408    
409            /**
410            * Finds the first layout in the ordered set where groupId = &#63;.
411            *
412            * <p>
413            * 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.
414            * </p>
415            *
416            * @param groupId the group ID to search with
417            * @param orderByComparator the comparator to order the set by
418            * @return the first matching layout
419            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
420            * @throws SystemException if a system exception occurred
421            */
422            public static com.liferay.portal.model.Layout findByGroupId_First(
423                    long groupId,
424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
425                    throws com.liferay.portal.NoSuchLayoutException,
426                            com.liferay.portal.kernel.exception.SystemException {
427                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
428            }
429    
430            /**
431            * Finds the last layout in the ordered set where groupId = &#63;.
432            *
433            * <p>
434            * 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.
435            * </p>
436            *
437            * @param groupId the group ID to search with
438            * @param orderByComparator the comparator to order the set by
439            * @return the last matching layout
440            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
441            * @throws SystemException if a system exception occurred
442            */
443            public static com.liferay.portal.model.Layout findByGroupId_Last(
444                    long groupId,
445                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
446                    throws com.liferay.portal.NoSuchLayoutException,
447                            com.liferay.portal.kernel.exception.SystemException {
448                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
449            }
450    
451            /**
452            * Finds the layouts before and after the current layout in the ordered set where groupId = &#63;.
453            *
454            * <p>
455            * 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.
456            * </p>
457            *
458            * @param plid the primary key of the current layout
459            * @param groupId the group ID to search with
460            * @param orderByComparator the comparator to order the set by
461            * @return the previous, current, and next layout
462            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
463            * @throws SystemException if a system exception occurred
464            */
465            public static com.liferay.portal.model.Layout[] findByGroupId_PrevAndNext(
466                    long plid, long groupId,
467                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
468                    throws com.liferay.portal.NoSuchLayoutException,
469                            com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .findByGroupId_PrevAndNext(plid, groupId, orderByComparator);
472            }
473    
474            /**
475            * Filters by the user's permissions and finds all the layouts where groupId = &#63;.
476            *
477            * @param groupId the group ID to search with
478            * @return the matching layouts that the user has permission to view
479            * @throws SystemException if a system exception occurred
480            */
481            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
482                    long groupId)
483                    throws com.liferay.portal.kernel.exception.SystemException {
484                    return getPersistence().filterFindByGroupId(groupId);
485            }
486    
487            /**
488            * Filters by the user's permissions and finds a range of all the layouts where groupId = &#63;.
489            *
490            * <p>
491            * 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.
492            * </p>
493            *
494            * @param groupId the group ID to search with
495            * @param start the lower bound of the range of layouts to return
496            * @param end the upper bound of the range of layouts to return (not inclusive)
497            * @return the range of matching layouts that the user has permission to view
498            * @throws SystemException if a system exception occurred
499            */
500            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
501                    long groupId, int start, int end)
502                    throws com.liferay.portal.kernel.exception.SystemException {
503                    return getPersistence().filterFindByGroupId(groupId, start, end);
504            }
505    
506            /**
507            * Filters by the user's permissions and finds an ordered range of all the layouts where groupId = &#63;.
508            *
509            * <p>
510            * 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.
511            * </p>
512            *
513            * @param groupId the group ID to search with
514            * @param start the lower bound of the range of layouts to return
515            * @param end the upper bound of the range of layouts to return (not inclusive)
516            * @param orderByComparator the comparator to order the results by
517            * @return the ordered range of matching layouts that the user has permission to view
518            * @throws SystemException if a system exception occurred
519            */
520            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
521                    long groupId, int start, int end,
522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
523                    throws com.liferay.portal.kernel.exception.SystemException {
524                    return getPersistence()
525                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
526            }
527    
528            /**
529            * Filters the layouts before and after the current layout in the ordered set where groupId = &#63;.
530            *
531            * <p>
532            * 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.
533            * </p>
534            *
535            * @param plid the primary key of the current layout
536            * @param groupId the group ID to search with
537            * @param orderByComparator the comparator to order the set by
538            * @return the previous, current, and next layout
539            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
540            * @throws SystemException if a system exception occurred
541            */
542            public static com.liferay.portal.model.Layout[] filterFindByGroupId_PrevAndNext(
543                    long plid, long groupId,
544                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
545                    throws com.liferay.portal.NoSuchLayoutException,
546                            com.liferay.portal.kernel.exception.SystemException {
547                    return getPersistence()
548                                       .filterFindByGroupId_PrevAndNext(plid, groupId,
549                            orderByComparator);
550            }
551    
552            /**
553            * Finds all the layouts where companyId = &#63;.
554            *
555            * @param companyId the company ID to search with
556            * @return the matching layouts
557            * @throws SystemException if a system exception occurred
558            */
559            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
560                    long companyId)
561                    throws com.liferay.portal.kernel.exception.SystemException {
562                    return getPersistence().findByCompanyId(companyId);
563            }
564    
565            /**
566            * Finds a range of all the layouts where companyId = &#63;.
567            *
568            * <p>
569            * 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.
570            * </p>
571            *
572            * @param companyId the company ID to search with
573            * @param start the lower bound of the range of layouts to return
574            * @param end the upper bound of the range of layouts to return (not inclusive)
575            * @return the range of matching layouts
576            * @throws SystemException if a system exception occurred
577            */
578            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
579                    long companyId, int start, int end)
580                    throws com.liferay.portal.kernel.exception.SystemException {
581                    return getPersistence().findByCompanyId(companyId, start, end);
582            }
583    
584            /**
585            * Finds an ordered range of all the layouts where companyId = &#63;.
586            *
587            * <p>
588            * 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.
589            * </p>
590            *
591            * @param companyId the company ID to search with
592            * @param start the lower bound of the range of layouts to return
593            * @param end the upper bound of the range of layouts to return (not inclusive)
594            * @param orderByComparator the comparator to order the results by
595            * @return the ordered range of matching layouts
596            * @throws SystemException if a system exception occurred
597            */
598            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
599                    long companyId, int start, int end,
600                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
601                    throws com.liferay.portal.kernel.exception.SystemException {
602                    return getPersistence()
603                                       .findByCompanyId(companyId, start, end, orderByComparator);
604            }
605    
606            /**
607            * Finds the first layout in the ordered set where companyId = &#63;.
608            *
609            * <p>
610            * 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.
611            * </p>
612            *
613            * @param companyId the company ID to search with
614            * @param orderByComparator the comparator to order the set by
615            * @return the first matching layout
616            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
617            * @throws SystemException if a system exception occurred
618            */
619            public static com.liferay.portal.model.Layout findByCompanyId_First(
620                    long companyId,
621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
622                    throws com.liferay.portal.NoSuchLayoutException,
623                            com.liferay.portal.kernel.exception.SystemException {
624                    return getPersistence()
625                                       .findByCompanyId_First(companyId, orderByComparator);
626            }
627    
628            /**
629            * Finds the last layout in the ordered set where companyId = &#63;.
630            *
631            * <p>
632            * 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.
633            * </p>
634            *
635            * @param companyId the company ID to search with
636            * @param orderByComparator the comparator to order the set by
637            * @return the last matching layout
638            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
639            * @throws SystemException if a system exception occurred
640            */
641            public static com.liferay.portal.model.Layout findByCompanyId_Last(
642                    long companyId,
643                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
644                    throws com.liferay.portal.NoSuchLayoutException,
645                            com.liferay.portal.kernel.exception.SystemException {
646                    return getPersistence()
647                                       .findByCompanyId_Last(companyId, orderByComparator);
648            }
649    
650            /**
651            * Finds the layouts before and after the current layout in the ordered set where companyId = &#63;.
652            *
653            * <p>
654            * 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.
655            * </p>
656            *
657            * @param plid the primary key of the current layout
658            * @param companyId the company ID to search with
659            * @param orderByComparator the comparator to order the set by
660            * @return the previous, current, and next layout
661            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
662            * @throws SystemException if a system exception occurred
663            */
664            public static com.liferay.portal.model.Layout[] findByCompanyId_PrevAndNext(
665                    long plid, long companyId,
666                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
667                    throws com.liferay.portal.NoSuchLayoutException,
668                            com.liferay.portal.kernel.exception.SystemException {
669                    return getPersistence()
670                                       .findByCompanyId_PrevAndNext(plid, companyId,
671                            orderByComparator);
672            }
673    
674            /**
675            * Finds the layout where dlFolderId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
676            *
677            * @param dlFolderId the dl folder ID to search with
678            * @return the matching layout
679            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
680            * @throws SystemException if a system exception occurred
681            */
682            public static com.liferay.portal.model.Layout findByDLFolderId(
683                    long dlFolderId)
684                    throws com.liferay.portal.NoSuchLayoutException,
685                            com.liferay.portal.kernel.exception.SystemException {
686                    return getPersistence().findByDLFolderId(dlFolderId);
687            }
688    
689            /**
690            * Finds the layout where dlFolderId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
691            *
692            * @param dlFolderId the dl folder ID to search with
693            * @return the matching layout, or <code>null</code> if a matching layout could not be found
694            * @throws SystemException if a system exception occurred
695            */
696            public static com.liferay.portal.model.Layout fetchByDLFolderId(
697                    long dlFolderId)
698                    throws com.liferay.portal.kernel.exception.SystemException {
699                    return getPersistence().fetchByDLFolderId(dlFolderId);
700            }
701    
702            /**
703            * Finds the layout where dlFolderId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
704            *
705            * @param dlFolderId the dl folder ID to search with
706            * @return the matching layout, or <code>null</code> if a matching layout could not be found
707            * @throws SystemException if a system exception occurred
708            */
709            public static com.liferay.portal.model.Layout fetchByDLFolderId(
710                    long dlFolderId, boolean retrieveFromCache)
711                    throws com.liferay.portal.kernel.exception.SystemException {
712                    return getPersistence().fetchByDLFolderId(dlFolderId, retrieveFromCache);
713            }
714    
715            /**
716            * Finds the layout where iconImageId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
717            *
718            * @param iconImageId the icon image ID to search with
719            * @return the matching layout
720            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
721            * @throws SystemException if a system exception occurred
722            */
723            public static com.liferay.portal.model.Layout findByIconImageId(
724                    long iconImageId)
725                    throws com.liferay.portal.NoSuchLayoutException,
726                            com.liferay.portal.kernel.exception.SystemException {
727                    return getPersistence().findByIconImageId(iconImageId);
728            }
729    
730            /**
731            * Finds the layout where iconImageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
732            *
733            * @param iconImageId the icon image ID to search with
734            * @return the matching layout, or <code>null</code> if a matching layout could not be found
735            * @throws SystemException if a system exception occurred
736            */
737            public static com.liferay.portal.model.Layout fetchByIconImageId(
738                    long iconImageId)
739                    throws com.liferay.portal.kernel.exception.SystemException {
740                    return getPersistence().fetchByIconImageId(iconImageId);
741            }
742    
743            /**
744            * Finds the layout where iconImageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
745            *
746            * @param iconImageId the icon image ID to search with
747            * @return the matching layout, or <code>null</code> if a matching layout could not be found
748            * @throws SystemException if a system exception occurred
749            */
750            public static com.liferay.portal.model.Layout fetchByIconImageId(
751                    long iconImageId, boolean retrieveFromCache)
752                    throws com.liferay.portal.kernel.exception.SystemException {
753                    return getPersistence()
754                                       .fetchByIconImageId(iconImageId, retrieveFromCache);
755            }
756    
757            /**
758            * Finds all the layouts where groupId = &#63; and privateLayout = &#63;.
759            *
760            * @param groupId the group ID to search with
761            * @param privateLayout the private layout to search with
762            * @return the matching layouts
763            * @throws SystemException if a system exception occurred
764            */
765            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
766                    long groupId, boolean privateLayout)
767                    throws com.liferay.portal.kernel.exception.SystemException {
768                    return getPersistence().findByG_P(groupId, privateLayout);
769            }
770    
771            /**
772            * Finds a range of all the layouts where groupId = &#63; and privateLayout = &#63;.
773            *
774            * <p>
775            * 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.
776            * </p>
777            *
778            * @param groupId the group ID to search with
779            * @param privateLayout the private layout to search with
780            * @param start the lower bound of the range of layouts to return
781            * @param end the upper bound of the range of layouts to return (not inclusive)
782            * @return the range of matching layouts
783            * @throws SystemException if a system exception occurred
784            */
785            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
786                    long groupId, boolean privateLayout, int start, int end)
787                    throws com.liferay.portal.kernel.exception.SystemException {
788                    return getPersistence().findByG_P(groupId, privateLayout, start, end);
789            }
790    
791            /**
792            * Finds an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63;.
793            *
794            * <p>
795            * 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.
796            * </p>
797            *
798            * @param groupId the group ID to search with
799            * @param privateLayout the private layout to search with
800            * @param start the lower bound of the range of layouts to return
801            * @param end the upper bound of the range of layouts to return (not inclusive)
802            * @param orderByComparator the comparator to order the results by
803            * @return the ordered range of matching layouts
804            * @throws SystemException if a system exception occurred
805            */
806            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
807                    long groupId, boolean privateLayout, int start, int end,
808                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
809                    throws com.liferay.portal.kernel.exception.SystemException {
810                    return getPersistence()
811                                       .findByG_P(groupId, privateLayout, start, end,
812                            orderByComparator);
813            }
814    
815            /**
816            * Finds the first layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
817            *
818            * <p>
819            * 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.
820            * </p>
821            *
822            * @param groupId the group ID to search with
823            * @param privateLayout the private layout to search with
824            * @param orderByComparator the comparator to order the set by
825            * @return the first matching layout
826            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
827            * @throws SystemException if a system exception occurred
828            */
829            public static com.liferay.portal.model.Layout findByG_P_First(
830                    long groupId, boolean privateLayout,
831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
832                    throws com.liferay.portal.NoSuchLayoutException,
833                            com.liferay.portal.kernel.exception.SystemException {
834                    return getPersistence()
835                                       .findByG_P_First(groupId, privateLayout, orderByComparator);
836            }
837    
838            /**
839            * Finds the last layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
840            *
841            * <p>
842            * 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.
843            * </p>
844            *
845            * @param groupId the group ID to search with
846            * @param privateLayout the private layout to search with
847            * @param orderByComparator the comparator to order the set by
848            * @return the last matching layout
849            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
850            * @throws SystemException if a system exception occurred
851            */
852            public static com.liferay.portal.model.Layout findByG_P_Last(long groupId,
853                    boolean privateLayout,
854                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
855                    throws com.liferay.portal.NoSuchLayoutException,
856                            com.liferay.portal.kernel.exception.SystemException {
857                    return getPersistence()
858                                       .findByG_P_Last(groupId, privateLayout, orderByComparator);
859            }
860    
861            /**
862            * Finds the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
863            *
864            * <p>
865            * 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.
866            * </p>
867            *
868            * @param plid the primary key of the current layout
869            * @param groupId the group ID to search with
870            * @param privateLayout the private layout to search with
871            * @param orderByComparator the comparator to order the set by
872            * @return the previous, current, and next layout
873            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
874            * @throws SystemException if a system exception occurred
875            */
876            public static com.liferay.portal.model.Layout[] findByG_P_PrevAndNext(
877                    long plid, long groupId, boolean privateLayout,
878                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
879                    throws com.liferay.portal.NoSuchLayoutException,
880                            com.liferay.portal.kernel.exception.SystemException {
881                    return getPersistence()
882                                       .findByG_P_PrevAndNext(plid, groupId, privateLayout,
883                            orderByComparator);
884            }
885    
886            /**
887            * Filters by the user's permissions and finds all the layouts where groupId = &#63; and privateLayout = &#63;.
888            *
889            * @param groupId the group ID to search with
890            * @param privateLayout the private layout to search with
891            * @return the matching layouts that the user has permission to view
892            * @throws SystemException if a system exception occurred
893            */
894            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
895                    long groupId, boolean privateLayout)
896                    throws com.liferay.portal.kernel.exception.SystemException {
897                    return getPersistence().filterFindByG_P(groupId, privateLayout);
898            }
899    
900            /**
901            * Filters by the user's permissions and finds a range of all the layouts where groupId = &#63; and privateLayout = &#63;.
902            *
903            * <p>
904            * 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.
905            * </p>
906            *
907            * @param groupId the group ID to search with
908            * @param privateLayout the private layout to search with
909            * @param start the lower bound of the range of layouts to return
910            * @param end the upper bound of the range of layouts to return (not inclusive)
911            * @return the range of matching layouts that the user has permission to view
912            * @throws SystemException if a system exception occurred
913            */
914            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
915                    long groupId, boolean privateLayout, int start, int end)
916                    throws com.liferay.portal.kernel.exception.SystemException {
917                    return getPersistence()
918                                       .filterFindByG_P(groupId, privateLayout, start, end);
919            }
920    
921            /**
922            * Filters by the user's permissions and finds an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63;.
923            *
924            * <p>
925            * 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.
926            * </p>
927            *
928            * @param groupId the group ID to search with
929            * @param privateLayout the private layout to search with
930            * @param start the lower bound of the range of layouts to return
931            * @param end the upper bound of the range of layouts to return (not inclusive)
932            * @param orderByComparator the comparator to order the results by
933            * @return the ordered range of matching layouts that the user has permission to view
934            * @throws SystemException if a system exception occurred
935            */
936            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
937                    long groupId, boolean privateLayout, int start, int end,
938                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
939                    throws com.liferay.portal.kernel.exception.SystemException {
940                    return getPersistence()
941                                       .filterFindByG_P(groupId, privateLayout, start, end,
942                            orderByComparator);
943            }
944    
945            /**
946            * Filters the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
947            *
948            * <p>
949            * 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.
950            * </p>
951            *
952            * @param plid the primary key of the current layout
953            * @param groupId the group ID to search with
954            * @param privateLayout the private layout to search with
955            * @param orderByComparator the comparator to order the set by
956            * @return the previous, current, and next layout
957            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
958            * @throws SystemException if a system exception occurred
959            */
960            public static com.liferay.portal.model.Layout[] filterFindByG_P_PrevAndNext(
961                    long plid, long groupId, boolean privateLayout,
962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
963                    throws com.liferay.portal.NoSuchLayoutException,
964                            com.liferay.portal.kernel.exception.SystemException {
965                    return getPersistence()
966                                       .filterFindByG_P_PrevAndNext(plid, groupId, privateLayout,
967                            orderByComparator);
968            }
969    
970            /**
971            * Finds 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.
972            *
973            * @param groupId the group ID to search with
974            * @param privateLayout the private layout to search with
975            * @param layoutId the layout ID to search with
976            * @return the matching layout
977            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
978            * @throws SystemException if a system exception occurred
979            */
980            public static com.liferay.portal.model.Layout findByG_P_L(long groupId,
981                    boolean privateLayout, long layoutId)
982                    throws com.liferay.portal.NoSuchLayoutException,
983                            com.liferay.portal.kernel.exception.SystemException {
984                    return getPersistence().findByG_P_L(groupId, privateLayout, layoutId);
985            }
986    
987            /**
988            * Finds 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.
989            *
990            * @param groupId the group ID to search with
991            * @param privateLayout the private layout to search with
992            * @param layoutId the layout ID to search with
993            * @return the matching layout, or <code>null</code> if a matching layout could not be found
994            * @throws SystemException if a system exception occurred
995            */
996            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
997                    boolean privateLayout, long layoutId)
998                    throws com.liferay.portal.kernel.exception.SystemException {
999                    return getPersistence().fetchByG_P_L(groupId, privateLayout, layoutId);
1000            }
1001    
1002            /**
1003            * Finds 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.
1004            *
1005            * @param groupId the group ID to search with
1006            * @param privateLayout the private layout to search with
1007            * @param layoutId the layout ID to search with
1008            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1009            * @throws SystemException if a system exception occurred
1010            */
1011            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1012                    boolean privateLayout, long layoutId, boolean retrieveFromCache)
1013                    throws com.liferay.portal.kernel.exception.SystemException {
1014                    return getPersistence()
1015                                       .fetchByG_P_L(groupId, privateLayout, layoutId,
1016                            retrieveFromCache);
1017            }
1018    
1019            /**
1020            * Finds all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1021            *
1022            * @param groupId the group ID to search with
1023            * @param privateLayout the private layout to search with
1024            * @param parentLayoutId the parent layout ID to search with
1025            * @return the matching layouts
1026            * @throws SystemException if a system exception occurred
1027            */
1028            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1029                    long groupId, boolean privateLayout, long parentLayoutId)
1030                    throws com.liferay.portal.kernel.exception.SystemException {
1031                    return getPersistence()
1032                                       .findByG_P_P(groupId, privateLayout, parentLayoutId);
1033            }
1034    
1035            /**
1036            * Finds a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1037            *
1038            * <p>
1039            * 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.
1040            * </p>
1041            *
1042            * @param groupId the group ID to search with
1043            * @param privateLayout the private layout to search with
1044            * @param parentLayoutId the parent layout ID to search with
1045            * @param start the lower bound of the range of layouts to return
1046            * @param end the upper bound of the range of layouts to return (not inclusive)
1047            * @return the range of matching layouts
1048            * @throws SystemException if a system exception occurred
1049            */
1050            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1051                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1052                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1053                    return getPersistence()
1054                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1055                            end);
1056            }
1057    
1058            /**
1059            * Finds an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1060            *
1061            * <p>
1062            * 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.
1063            * </p>
1064            *
1065            * @param groupId the group ID to search with
1066            * @param privateLayout the private layout to search with
1067            * @param parentLayoutId the parent layout ID to search with
1068            * @param start the lower bound of the range of layouts to return
1069            * @param end the upper bound of the range of layouts to return (not inclusive)
1070            * @param orderByComparator the comparator to order the results by
1071            * @return the ordered range of matching layouts
1072            * @throws SystemException if a system exception occurred
1073            */
1074            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1075                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1076                    int end,
1077                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1078                    throws com.liferay.portal.kernel.exception.SystemException {
1079                    return getPersistence()
1080                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1081                            end, orderByComparator);
1082            }
1083    
1084            /**
1085            * Finds the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1086            *
1087            * <p>
1088            * 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.
1089            * </p>
1090            *
1091            * @param groupId the group ID to search with
1092            * @param privateLayout the private layout to search with
1093            * @param parentLayoutId the parent layout ID to search with
1094            * @param orderByComparator the comparator to order the set by
1095            * @return the first matching layout
1096            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1097            * @throws SystemException if a system exception occurred
1098            */
1099            public static com.liferay.portal.model.Layout findByG_P_P_First(
1100                    long groupId, boolean privateLayout, long parentLayoutId,
1101                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1102                    throws com.liferay.portal.NoSuchLayoutException,
1103                            com.liferay.portal.kernel.exception.SystemException {
1104                    return getPersistence()
1105                                       .findByG_P_P_First(groupId, privateLayout, parentLayoutId,
1106                            orderByComparator);
1107            }
1108    
1109            /**
1110            * Finds the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1111            *
1112            * <p>
1113            * 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.
1114            * </p>
1115            *
1116            * @param groupId the group ID to search with
1117            * @param privateLayout the private layout to search with
1118            * @param parentLayoutId the parent layout ID to search with
1119            * @param orderByComparator the comparator to order the set by
1120            * @return the last matching layout
1121            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1122            * @throws SystemException if a system exception occurred
1123            */
1124            public static com.liferay.portal.model.Layout findByG_P_P_Last(
1125                    long groupId, boolean privateLayout, long parentLayoutId,
1126                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1127                    throws com.liferay.portal.NoSuchLayoutException,
1128                            com.liferay.portal.kernel.exception.SystemException {
1129                    return getPersistence()
1130                                       .findByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1131                            orderByComparator);
1132            }
1133    
1134            /**
1135            * Finds the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1136            *
1137            * <p>
1138            * 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.
1139            * </p>
1140            *
1141            * @param plid the primary key of the current layout
1142            * @param groupId the group ID to search with
1143            * @param privateLayout the private layout to search with
1144            * @param parentLayoutId the parent layout ID to search with
1145            * @param orderByComparator the comparator to order the set by
1146            * @return the previous, current, and next layout
1147            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1148            * @throws SystemException if a system exception occurred
1149            */
1150            public static com.liferay.portal.model.Layout[] findByG_P_P_PrevAndNext(
1151                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1153                    throws com.liferay.portal.NoSuchLayoutException,
1154                            com.liferay.portal.kernel.exception.SystemException {
1155                    return getPersistence()
1156                                       .findByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1157                            parentLayoutId, orderByComparator);
1158            }
1159    
1160            /**
1161            * Filters by the user's permissions and finds all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1162            *
1163            * @param groupId the group ID to search with
1164            * @param privateLayout the private layout to search with
1165            * @param parentLayoutId the parent layout ID to search with
1166            * @return the matching layouts that the user has permission to view
1167            * @throws SystemException if a system exception occurred
1168            */
1169            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1170                    long groupId, boolean privateLayout, long parentLayoutId)
1171                    throws com.liferay.portal.kernel.exception.SystemException {
1172                    return getPersistence()
1173                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId);
1174            }
1175    
1176            /**
1177            * Filters by the user's permissions and finds a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1178            *
1179            * <p>
1180            * 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.
1181            * </p>
1182            *
1183            * @param groupId the group ID to search with
1184            * @param privateLayout the private layout to search with
1185            * @param parentLayoutId the parent layout ID to search with
1186            * @param start the lower bound of the range of layouts to return
1187            * @param end the upper bound of the range of layouts to return (not inclusive)
1188            * @return the range of matching layouts that the user has permission to view
1189            * @throws SystemException if a system exception occurred
1190            */
1191            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1192                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1193                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1194                    return getPersistence()
1195                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1196                            start, end);
1197            }
1198    
1199            /**
1200            * Filters by the user's permissions and finds an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1201            *
1202            * <p>
1203            * 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.
1204            * </p>
1205            *
1206            * @param groupId the group ID to search with
1207            * @param privateLayout the private layout to search with
1208            * @param parentLayoutId the parent layout ID to search with
1209            * @param start the lower bound of the range of layouts to return
1210            * @param end the upper bound of the range of layouts to return (not inclusive)
1211            * @param orderByComparator the comparator to order the results by
1212            * @return the ordered range of matching layouts that the user has permission to view
1213            * @throws SystemException if a system exception occurred
1214            */
1215            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1216                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1217                    int end,
1218                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1219                    throws com.liferay.portal.kernel.exception.SystemException {
1220                    return getPersistence()
1221                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1222                            start, end, orderByComparator);
1223            }
1224    
1225            /**
1226            * Filters the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1227            *
1228            * <p>
1229            * 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.
1230            * </p>
1231            *
1232            * @param plid the primary key of the current layout
1233            * @param groupId the group ID to search with
1234            * @param privateLayout the private layout to search with
1235            * @param parentLayoutId the parent layout ID to search with
1236            * @param orderByComparator the comparator to order the set by
1237            * @return the previous, current, and next layout
1238            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1239            * @throws SystemException if a system exception occurred
1240            */
1241            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_PrevAndNext(
1242                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1244                    throws com.liferay.portal.NoSuchLayoutException,
1245                            com.liferay.portal.kernel.exception.SystemException {
1246                    return getPersistence()
1247                                       .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1248                            parentLayoutId, orderByComparator);
1249            }
1250    
1251            /**
1252            * Finds 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.
1253            *
1254            * @param groupId the group ID to search with
1255            * @param privateLayout the private layout to search with
1256            * @param friendlyURL the friendly u r l to search with
1257            * @return the matching layout
1258            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1259            * @throws SystemException if a system exception occurred
1260            */
1261            public static com.liferay.portal.model.Layout findByG_P_F(long groupId,
1262                    boolean privateLayout, java.lang.String friendlyURL)
1263                    throws com.liferay.portal.NoSuchLayoutException,
1264                            com.liferay.portal.kernel.exception.SystemException {
1265                    return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL);
1266            }
1267    
1268            /**
1269            * Finds 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.
1270            *
1271            * @param groupId the group ID to search with
1272            * @param privateLayout the private layout to search with
1273            * @param friendlyURL the friendly u r l to search with
1274            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1275            * @throws SystemException if a system exception occurred
1276            */
1277            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1278                    boolean privateLayout, java.lang.String friendlyURL)
1279                    throws com.liferay.portal.kernel.exception.SystemException {
1280                    return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL);
1281            }
1282    
1283            /**
1284            * Finds 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.
1285            *
1286            * @param groupId the group ID to search with
1287            * @param privateLayout the private layout to search with
1288            * @param friendlyURL the friendly u r l to search with
1289            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1290            * @throws SystemException if a system exception occurred
1291            */
1292            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1293                    boolean privateLayout, java.lang.String friendlyURL,
1294                    boolean retrieveFromCache)
1295                    throws com.liferay.portal.kernel.exception.SystemException {
1296                    return getPersistence()
1297                                       .fetchByG_P_F(groupId, privateLayout, friendlyURL,
1298                            retrieveFromCache);
1299            }
1300    
1301            /**
1302            * Finds all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1303            *
1304            * @param groupId the group ID to search with
1305            * @param privateLayout the private layout to search with
1306            * @param type the type to search with
1307            * @return the matching layouts
1308            * @throws SystemException if a system exception occurred
1309            */
1310            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
1311                    long groupId, boolean privateLayout, java.lang.String type)
1312                    throws com.liferay.portal.kernel.exception.SystemException {
1313                    return getPersistence().findByG_P_T(groupId, privateLayout, type);
1314            }
1315    
1316            /**
1317            * Finds a range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1318            *
1319            * <p>
1320            * 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.
1321            * </p>
1322            *
1323            * @param groupId the group ID to search with
1324            * @param privateLayout the private layout to search with
1325            * @param type the type to search with
1326            * @param start the lower bound of the range of layouts to return
1327            * @param end the upper bound of the range of layouts to return (not inclusive)
1328            * @return the range of matching layouts
1329            * @throws SystemException if a system exception occurred
1330            */
1331            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
1332                    long groupId, boolean privateLayout, java.lang.String type, int start,
1333                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1334                    return getPersistence()
1335                                       .findByG_P_T(groupId, privateLayout, type, start, end);
1336            }
1337    
1338            /**
1339            * Finds an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1340            *
1341            * <p>
1342            * 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.
1343            * </p>
1344            *
1345            * @param groupId the group ID to search with
1346            * @param privateLayout the private layout to search with
1347            * @param type the type to search with
1348            * @param start the lower bound of the range of layouts to return
1349            * @param end the upper bound of the range of layouts to return (not inclusive)
1350            * @param orderByComparator the comparator to order the results by
1351            * @return the ordered range of matching layouts
1352            * @throws SystemException if a system exception occurred
1353            */
1354            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
1355                    long groupId, boolean privateLayout, java.lang.String type, int start,
1356                    int end,
1357                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1358                    throws com.liferay.portal.kernel.exception.SystemException {
1359                    return getPersistence()
1360                                       .findByG_P_T(groupId, privateLayout, type, start, end,
1361                            orderByComparator);
1362            }
1363    
1364            /**
1365            * Finds the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1366            *
1367            * <p>
1368            * 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.
1369            * </p>
1370            *
1371            * @param groupId the group ID to search with
1372            * @param privateLayout the private layout to search with
1373            * @param type the type to search with
1374            * @param orderByComparator the comparator to order the set by
1375            * @return the first matching layout
1376            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1377            * @throws SystemException if a system exception occurred
1378            */
1379            public static com.liferay.portal.model.Layout findByG_P_T_First(
1380                    long groupId, boolean privateLayout, java.lang.String type,
1381                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1382                    throws com.liferay.portal.NoSuchLayoutException,
1383                            com.liferay.portal.kernel.exception.SystemException {
1384                    return getPersistence()
1385                                       .findByG_P_T_First(groupId, privateLayout, type,
1386                            orderByComparator);
1387            }
1388    
1389            /**
1390            * Finds the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1391            *
1392            * <p>
1393            * 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.
1394            * </p>
1395            *
1396            * @param groupId the group ID to search with
1397            * @param privateLayout the private layout to search with
1398            * @param type the type to search with
1399            * @param orderByComparator the comparator to order the set by
1400            * @return the last matching layout
1401            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1402            * @throws SystemException if a system exception occurred
1403            */
1404            public static com.liferay.portal.model.Layout findByG_P_T_Last(
1405                    long groupId, boolean privateLayout, java.lang.String type,
1406                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1407                    throws com.liferay.portal.NoSuchLayoutException,
1408                            com.liferay.portal.kernel.exception.SystemException {
1409                    return getPersistence()
1410                                       .findByG_P_T_Last(groupId, privateLayout, type,
1411                            orderByComparator);
1412            }
1413    
1414            /**
1415            * Finds the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1416            *
1417            * <p>
1418            * 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.
1419            * </p>
1420            *
1421            * @param plid the primary key of the current layout
1422            * @param groupId the group ID to search with
1423            * @param privateLayout the private layout to search with
1424            * @param type the type to search with
1425            * @param orderByComparator the comparator to order the set by
1426            * @return the previous, current, and next layout
1427            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1428            * @throws SystemException if a system exception occurred
1429            */
1430            public static com.liferay.portal.model.Layout[] findByG_P_T_PrevAndNext(
1431                    long plid, long groupId, boolean privateLayout, java.lang.String type,
1432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1433                    throws com.liferay.portal.NoSuchLayoutException,
1434                            com.liferay.portal.kernel.exception.SystemException {
1435                    return getPersistence()
1436                                       .findByG_P_T_PrevAndNext(plid, groupId, privateLayout, type,
1437                            orderByComparator);
1438            }
1439    
1440            /**
1441            * Filters by the user's permissions and finds all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1442            *
1443            * @param groupId the group ID to search with
1444            * @param privateLayout the private layout to search with
1445            * @param type the type to search with
1446            * @return the matching layouts that the user has permission to view
1447            * @throws SystemException if a system exception occurred
1448            */
1449            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
1450                    long groupId, boolean privateLayout, java.lang.String type)
1451                    throws com.liferay.portal.kernel.exception.SystemException {
1452                    return getPersistence().filterFindByG_P_T(groupId, privateLayout, type);
1453            }
1454    
1455            /**
1456            * Filters by the user's permissions and finds a range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1457            *
1458            * <p>
1459            * 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.
1460            * </p>
1461            *
1462            * @param groupId the group ID to search with
1463            * @param privateLayout the private layout to search with
1464            * @param type the type to search with
1465            * @param start the lower bound of the range of layouts to return
1466            * @param end the upper bound of the range of layouts to return (not inclusive)
1467            * @return the range of matching layouts that the user has permission to view
1468            * @throws SystemException if a system exception occurred
1469            */
1470            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
1471                    long groupId, boolean privateLayout, java.lang.String type, int start,
1472                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1473                    return getPersistence()
1474                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end);
1475            }
1476    
1477            /**
1478            * Filters by the user's permissions and finds an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1479            *
1480            * <p>
1481            * 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.
1482            * </p>
1483            *
1484            * @param groupId the group ID to search with
1485            * @param privateLayout the private layout to search with
1486            * @param type the type to search with
1487            * @param start the lower bound of the range of layouts to return
1488            * @param end the upper bound of the range of layouts to return (not inclusive)
1489            * @param orderByComparator the comparator to order the results by
1490            * @return the ordered range of matching layouts that the user has permission to view
1491            * @throws SystemException if a system exception occurred
1492            */
1493            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
1494                    long groupId, boolean privateLayout, java.lang.String type, int start,
1495                    int end,
1496                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1497                    throws com.liferay.portal.kernel.exception.SystemException {
1498                    return getPersistence()
1499                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end,
1500                            orderByComparator);
1501            }
1502    
1503            /**
1504            * Filters the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1505            *
1506            * <p>
1507            * 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.
1508            * </p>
1509            *
1510            * @param plid the primary key of the current layout
1511            * @param groupId the group ID to search with
1512            * @param privateLayout the private layout to search with
1513            * @param type the type to search with
1514            * @param orderByComparator the comparator to order the set by
1515            * @return the previous, current, and next layout
1516            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1517            * @throws SystemException if a system exception occurred
1518            */
1519            public static com.liferay.portal.model.Layout[] filterFindByG_P_T_PrevAndNext(
1520                    long plid, long groupId, boolean privateLayout, java.lang.String type,
1521                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1522                    throws com.liferay.portal.NoSuchLayoutException,
1523                            com.liferay.portal.kernel.exception.SystemException {
1524                    return getPersistence()
1525                                       .filterFindByG_P_T_PrevAndNext(plid, groupId, privateLayout,
1526                            type, orderByComparator);
1527            }
1528    
1529            /**
1530            * Finds all the layouts.
1531            *
1532            * @return the layouts
1533            * @throws SystemException if a system exception occurred
1534            */
1535            public static java.util.List<com.liferay.portal.model.Layout> findAll()
1536                    throws com.liferay.portal.kernel.exception.SystemException {
1537                    return getPersistence().findAll();
1538            }
1539    
1540            /**
1541            * Finds a range of all the layouts.
1542            *
1543            * <p>
1544            * 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.
1545            * </p>
1546            *
1547            * @param start the lower bound of the range of layouts to return
1548            * @param end the upper bound of the range of layouts to return (not inclusive)
1549            * @return the range of layouts
1550            * @throws SystemException if a system exception occurred
1551            */
1552            public static java.util.List<com.liferay.portal.model.Layout> findAll(
1553                    int start, int end)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence().findAll(start, end);
1556            }
1557    
1558            /**
1559            * Finds an ordered range of all the layouts.
1560            *
1561            * <p>
1562            * 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.
1563            * </p>
1564            *
1565            * @param start the lower bound of the range of layouts to return
1566            * @param end the upper bound of the range of layouts to return (not inclusive)
1567            * @param orderByComparator the comparator to order the results by
1568            * @return the ordered range of layouts
1569            * @throws SystemException if a system exception occurred
1570            */
1571            public static java.util.List<com.liferay.portal.model.Layout> findAll(
1572                    int start, int end,
1573                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1574                    throws com.liferay.portal.kernel.exception.SystemException {
1575                    return getPersistence().findAll(start, end, orderByComparator);
1576            }
1577    
1578            /**
1579            * Removes all the layouts where uuid = &#63; from the database.
1580            *
1581            * @param uuid the uuid to search with
1582            * @throws SystemException if a system exception occurred
1583            */
1584            public static void removeByUuid(java.lang.String uuid)
1585                    throws com.liferay.portal.kernel.exception.SystemException {
1586                    getPersistence().removeByUuid(uuid);
1587            }
1588    
1589            /**
1590            * Removes the layout where uuid = &#63; and groupId = &#63; from the database.
1591            *
1592            * @param uuid the uuid to search with
1593            * @param groupId the group ID to search with
1594            * @throws SystemException if a system exception occurred
1595            */
1596            public static void removeByUUID_G(java.lang.String uuid, long groupId)
1597                    throws com.liferay.portal.NoSuchLayoutException,
1598                            com.liferay.portal.kernel.exception.SystemException {
1599                    getPersistence().removeByUUID_G(uuid, groupId);
1600            }
1601    
1602            /**
1603            * Removes all the layouts where groupId = &#63; from the database.
1604            *
1605            * @param groupId the group ID to search with
1606            * @throws SystemException if a system exception occurred
1607            */
1608            public static void removeByGroupId(long groupId)
1609                    throws com.liferay.portal.kernel.exception.SystemException {
1610                    getPersistence().removeByGroupId(groupId);
1611            }
1612    
1613            /**
1614            * Removes all the layouts where companyId = &#63; from the database.
1615            *
1616            * @param companyId the company ID to search with
1617            * @throws SystemException if a system exception occurred
1618            */
1619            public static void removeByCompanyId(long companyId)
1620                    throws com.liferay.portal.kernel.exception.SystemException {
1621                    getPersistence().removeByCompanyId(companyId);
1622            }
1623    
1624            /**
1625            * Removes the layout where dlFolderId = &#63; from the database.
1626            *
1627            * @param dlFolderId the dl folder ID to search with
1628            * @throws SystemException if a system exception occurred
1629            */
1630            public static void removeByDLFolderId(long dlFolderId)
1631                    throws com.liferay.portal.NoSuchLayoutException,
1632                            com.liferay.portal.kernel.exception.SystemException {
1633                    getPersistence().removeByDLFolderId(dlFolderId);
1634            }
1635    
1636            /**
1637            * Removes the layout where iconImageId = &#63; from the database.
1638            *
1639            * @param iconImageId the icon image ID to search with
1640            * @throws SystemException if a system exception occurred
1641            */
1642            public static void removeByIconImageId(long iconImageId)
1643                    throws com.liferay.portal.NoSuchLayoutException,
1644                            com.liferay.portal.kernel.exception.SystemException {
1645                    getPersistence().removeByIconImageId(iconImageId);
1646            }
1647    
1648            /**
1649            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; from the database.
1650            *
1651            * @param groupId the group ID to search with
1652            * @param privateLayout the private layout to search with
1653            * @throws SystemException if a system exception occurred
1654            */
1655            public static void removeByG_P(long groupId, boolean privateLayout)
1656                    throws com.liferay.portal.kernel.exception.SystemException {
1657                    getPersistence().removeByG_P(groupId, privateLayout);
1658            }
1659    
1660            /**
1661            * Removes the layout where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; from the database.
1662            *
1663            * @param groupId the group ID to search with
1664            * @param privateLayout the private layout to search with
1665            * @param layoutId the layout ID to search with
1666            * @throws SystemException if a system exception occurred
1667            */
1668            public static void removeByG_P_L(long groupId, boolean privateLayout,
1669                    long layoutId)
1670                    throws com.liferay.portal.NoSuchLayoutException,
1671                            com.liferay.portal.kernel.exception.SystemException {
1672                    getPersistence().removeByG_P_L(groupId, privateLayout, layoutId);
1673            }
1674    
1675            /**
1676            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; from the database.
1677            *
1678            * @param groupId the group ID to search with
1679            * @param privateLayout the private layout to search with
1680            * @param parentLayoutId the parent layout ID to search with
1681            * @throws SystemException if a system exception occurred
1682            */
1683            public static void removeByG_P_P(long groupId, boolean privateLayout,
1684                    long parentLayoutId)
1685                    throws com.liferay.portal.kernel.exception.SystemException {
1686                    getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId);
1687            }
1688    
1689            /**
1690            * Removes the layout where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; from the database.
1691            *
1692            * @param groupId the group ID to search with
1693            * @param privateLayout the private layout to search with
1694            * @param friendlyURL the friendly u r l to search with
1695            * @throws SystemException if a system exception occurred
1696            */
1697            public static void removeByG_P_F(long groupId, boolean privateLayout,
1698                    java.lang.String friendlyURL)
1699                    throws com.liferay.portal.NoSuchLayoutException,
1700                            com.liferay.portal.kernel.exception.SystemException {
1701                    getPersistence().removeByG_P_F(groupId, privateLayout, friendlyURL);
1702            }
1703    
1704            /**
1705            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63; from the database.
1706            *
1707            * @param groupId the group ID to search with
1708            * @param privateLayout the private layout to search with
1709            * @param type the type to search with
1710            * @throws SystemException if a system exception occurred
1711            */
1712            public static void removeByG_P_T(long groupId, boolean privateLayout,
1713                    java.lang.String type)
1714                    throws com.liferay.portal.kernel.exception.SystemException {
1715                    getPersistence().removeByG_P_T(groupId, privateLayout, type);
1716            }
1717    
1718            /**
1719            * Removes all the layouts from the database.
1720            *
1721            * @throws SystemException if a system exception occurred
1722            */
1723            public static void removeAll()
1724                    throws com.liferay.portal.kernel.exception.SystemException {
1725                    getPersistence().removeAll();
1726            }
1727    
1728            /**
1729            * Counts all the layouts where uuid = &#63;.
1730            *
1731            * @param uuid the uuid to search with
1732            * @return the number of matching layouts
1733            * @throws SystemException if a system exception occurred
1734            */
1735            public static int countByUuid(java.lang.String uuid)
1736                    throws com.liferay.portal.kernel.exception.SystemException {
1737                    return getPersistence().countByUuid(uuid);
1738            }
1739    
1740            /**
1741            * Counts all the layouts where uuid = &#63; and groupId = &#63;.
1742            *
1743            * @param uuid the uuid to search with
1744            * @param groupId the group ID to search with
1745            * @return the number of matching layouts
1746            * @throws SystemException if a system exception occurred
1747            */
1748            public static int countByUUID_G(java.lang.String uuid, long groupId)
1749                    throws com.liferay.portal.kernel.exception.SystemException {
1750                    return getPersistence().countByUUID_G(uuid, groupId);
1751            }
1752    
1753            /**
1754            * Counts all the layouts where groupId = &#63;.
1755            *
1756            * @param groupId the group ID to search with
1757            * @return the number of matching layouts
1758            * @throws SystemException if a system exception occurred
1759            */
1760            public static int countByGroupId(long groupId)
1761                    throws com.liferay.portal.kernel.exception.SystemException {
1762                    return getPersistence().countByGroupId(groupId);
1763            }
1764    
1765            /**
1766            * Filters by the user's permissions and counts all the layouts where groupId = &#63;.
1767            *
1768            * @param groupId the group ID to search with
1769            * @return the number of matching layouts that the user has permission to view
1770            * @throws SystemException if a system exception occurred
1771            */
1772            public static int filterCountByGroupId(long groupId)
1773                    throws com.liferay.portal.kernel.exception.SystemException {
1774                    return getPersistence().filterCountByGroupId(groupId);
1775            }
1776    
1777            /**
1778            * Counts all the layouts where companyId = &#63;.
1779            *
1780            * @param companyId the company ID to search with
1781            * @return the number of matching layouts
1782            * @throws SystemException if a system exception occurred
1783            */
1784            public static int countByCompanyId(long companyId)
1785                    throws com.liferay.portal.kernel.exception.SystemException {
1786                    return getPersistence().countByCompanyId(companyId);
1787            }
1788    
1789            /**
1790            * Counts all the layouts where dlFolderId = &#63;.
1791            *
1792            * @param dlFolderId the dl folder ID to search with
1793            * @return the number of matching layouts
1794            * @throws SystemException if a system exception occurred
1795            */
1796            public static int countByDLFolderId(long dlFolderId)
1797                    throws com.liferay.portal.kernel.exception.SystemException {
1798                    return getPersistence().countByDLFolderId(dlFolderId);
1799            }
1800    
1801            /**
1802            * Counts all the layouts where iconImageId = &#63;.
1803            *
1804            * @param iconImageId the icon image ID to search with
1805            * @return the number of matching layouts
1806            * @throws SystemException if a system exception occurred
1807            */
1808            public static int countByIconImageId(long iconImageId)
1809                    throws com.liferay.portal.kernel.exception.SystemException {
1810                    return getPersistence().countByIconImageId(iconImageId);
1811            }
1812    
1813            /**
1814            * Counts all the layouts where groupId = &#63; and privateLayout = &#63;.
1815            *
1816            * @param groupId the group ID to search with
1817            * @param privateLayout the private layout to search with
1818            * @return the number of matching layouts
1819            * @throws SystemException if a system exception occurred
1820            */
1821            public static int countByG_P(long groupId, boolean privateLayout)
1822                    throws com.liferay.portal.kernel.exception.SystemException {
1823                    return getPersistence().countByG_P(groupId, privateLayout);
1824            }
1825    
1826            /**
1827            * Filters by the user's permissions and counts all the layouts where groupId = &#63; and privateLayout = &#63;.
1828            *
1829            * @param groupId the group ID to search with
1830            * @param privateLayout the private layout to search with
1831            * @return the number of matching layouts that the user has permission to view
1832            * @throws SystemException if a system exception occurred
1833            */
1834            public static int filterCountByG_P(long groupId, boolean privateLayout)
1835                    throws com.liferay.portal.kernel.exception.SystemException {
1836                    return getPersistence().filterCountByG_P(groupId, privateLayout);
1837            }
1838    
1839            /**
1840            * Counts all the layouts where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
1841            *
1842            * @param groupId the group ID to search with
1843            * @param privateLayout the private layout to search with
1844            * @param layoutId the layout ID to search with
1845            * @return the number of matching layouts
1846            * @throws SystemException if a system exception occurred
1847            */
1848            public static int countByG_P_L(long groupId, boolean privateLayout,
1849                    long layoutId)
1850                    throws com.liferay.portal.kernel.exception.SystemException {
1851                    return getPersistence().countByG_P_L(groupId, privateLayout, layoutId);
1852            }
1853    
1854            /**
1855            * Counts all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1856            *
1857            * @param groupId the group ID to search with
1858            * @param privateLayout the private layout to search with
1859            * @param parentLayoutId the parent layout ID to search with
1860            * @return the number of matching layouts
1861            * @throws SystemException if a system exception occurred
1862            */
1863            public static int countByG_P_P(long groupId, boolean privateLayout,
1864                    long parentLayoutId)
1865                    throws com.liferay.portal.kernel.exception.SystemException {
1866                    return getPersistence()
1867                                       .countByG_P_P(groupId, privateLayout, parentLayoutId);
1868            }
1869    
1870            /**
1871            * Filters by the user's permissions and counts all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1872            *
1873            * @param groupId the group ID to search with
1874            * @param privateLayout the private layout to search with
1875            * @param parentLayoutId the parent layout ID to search with
1876            * @return the number of matching layouts that the user has permission to view
1877            * @throws SystemException if a system exception occurred
1878            */
1879            public static int filterCountByG_P_P(long groupId, boolean privateLayout,
1880                    long parentLayoutId)
1881                    throws com.liferay.portal.kernel.exception.SystemException {
1882                    return getPersistence()
1883                                       .filterCountByG_P_P(groupId, privateLayout, parentLayoutId);
1884            }
1885    
1886            /**
1887            * Counts all the layouts where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1888            *
1889            * @param groupId the group ID to search with
1890            * @param privateLayout the private layout to search with
1891            * @param friendlyURL the friendly u r l to search with
1892            * @return the number of matching layouts
1893            * @throws SystemException if a system exception occurred
1894            */
1895            public static int countByG_P_F(long groupId, boolean privateLayout,
1896                    java.lang.String friendlyURL)
1897                    throws com.liferay.portal.kernel.exception.SystemException {
1898                    return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL);
1899            }
1900    
1901            /**
1902            * Counts all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1903            *
1904            * @param groupId the group ID to search with
1905            * @param privateLayout the private layout to search with
1906            * @param type the type to search with
1907            * @return the number of matching layouts
1908            * @throws SystemException if a system exception occurred
1909            */
1910            public static int countByG_P_T(long groupId, boolean privateLayout,
1911                    java.lang.String type)
1912                    throws com.liferay.portal.kernel.exception.SystemException {
1913                    return getPersistence().countByG_P_T(groupId, privateLayout, type);
1914            }
1915    
1916            /**
1917            * Filters by the user's permissions and counts all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1918            *
1919            * @param groupId the group ID to search with
1920            * @param privateLayout the private layout to search with
1921            * @param type the type to search with
1922            * @return the number of matching layouts that the user has permission to view
1923            * @throws SystemException if a system exception occurred
1924            */
1925            public static int filterCountByG_P_T(long groupId, boolean privateLayout,
1926                    java.lang.String type)
1927                    throws com.liferay.portal.kernel.exception.SystemException {
1928                    return getPersistence().filterCountByG_P_T(groupId, privateLayout, type);
1929            }
1930    
1931            /**
1932            * Counts all the layouts.
1933            *
1934            * @return the number of layouts
1935            * @throws SystemException if a system exception occurred
1936            */
1937            public static int countAll()
1938                    throws com.liferay.portal.kernel.exception.SystemException {
1939                    return getPersistence().countAll();
1940            }
1941    
1942            public static LayoutPersistence getPersistence() {
1943                    if (_persistence == null) {
1944                            _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName());
1945    
1946                            ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence");
1947                    }
1948    
1949                    return _persistence;
1950            }
1951    
1952            public void setPersistence(LayoutPersistence persistence) {
1953                    _persistence = persistence;
1954    
1955                    ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence");
1956            }
1957    
1958            private static LayoutPersistence _persistence;
1959    }