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