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