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