001    /**
002     * Copyright (c) 2000-2012 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#update(com.liferay.portal.model.BaseModel, boolean)
097             */
098            public static Layout update(Layout layout, boolean merge)
099                    throws SystemException {
100                    return getPersistence().update(layout, merge);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
105             */
106            public static Layout update(Layout layout, boolean merge,
107                    ServiceContext serviceContext) throws SystemException {
108                    return getPersistence().update(layout, merge, serviceContext);
109            }
110    
111            /**
112            * Caches the layout in the entity cache if it is enabled.
113            *
114            * @param layout the layout
115            */
116            public static void cacheResult(com.liferay.portal.model.Layout layout) {
117                    getPersistence().cacheResult(layout);
118            }
119    
120            /**
121            * Caches the layouts in the entity cache if it is enabled.
122            *
123            * @param layouts the layouts
124            */
125            public static void cacheResult(
126                    java.util.List<com.liferay.portal.model.Layout> layouts) {
127                    getPersistence().cacheResult(layouts);
128            }
129    
130            /**
131            * Creates a new layout with the primary key. Does not add the layout to the database.
132            *
133            * @param plid the primary key for the new layout
134            * @return the new layout
135            */
136            public static com.liferay.portal.model.Layout create(long plid) {
137                    return getPersistence().create(plid);
138            }
139    
140            /**
141            * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners.
142            *
143            * @param plid the primary key of the layout
144            * @return the layout that was removed
145            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
146            * @throws SystemException if a system exception occurred
147            */
148            public static com.liferay.portal.model.Layout remove(long plid)
149                    throws com.liferay.portal.NoSuchLayoutException,
150                            com.liferay.portal.kernel.exception.SystemException {
151                    return getPersistence().remove(plid);
152            }
153    
154            public static com.liferay.portal.model.Layout updateImpl(
155                    com.liferay.portal.model.Layout layout, boolean merge)
156                    throws com.liferay.portal.kernel.exception.SystemException {
157                    return getPersistence().updateImpl(layout, merge);
158            }
159    
160            /**
161            * Returns the layout with the primary key or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
162            *
163            * @param plid the primary key of the layout
164            * @return the layout
165            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
166            * @throws SystemException if a system exception occurred
167            */
168            public static com.liferay.portal.model.Layout findByPrimaryKey(long plid)
169                    throws com.liferay.portal.NoSuchLayoutException,
170                            com.liferay.portal.kernel.exception.SystemException {
171                    return getPersistence().findByPrimaryKey(plid);
172            }
173    
174            /**
175            * Returns the layout with the primary key or returns <code>null</code> if it could not be found.
176            *
177            * @param plid the primary key of the layout
178            * @return the layout, or <code>null</code> if a layout with the primary key could not be found
179            * @throws SystemException if a system exception occurred
180            */
181            public static com.liferay.portal.model.Layout fetchByPrimaryKey(long plid)
182                    throws com.liferay.portal.kernel.exception.SystemException {
183                    return getPersistence().fetchByPrimaryKey(plid);
184            }
185    
186            /**
187            * Returns all the layouts where uuid = &#63;.
188            *
189            * @param uuid the uuid
190            * @return the matching layouts
191            * @throws SystemException if a system exception occurred
192            */
193            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
194                    java.lang.String uuid)
195                    throws com.liferay.portal.kernel.exception.SystemException {
196                    return getPersistence().findByUuid(uuid);
197            }
198    
199            /**
200            * Returns a range of all the layouts where uuid = &#63;.
201            *
202            * <p>
203            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
204            * </p>
205            *
206            * @param uuid the uuid
207            * @param start the lower bound of the range of layouts
208            * @param end the upper bound of the range of layouts (not inclusive)
209            * @return the range of matching layouts
210            * @throws SystemException if a system exception occurred
211            */
212            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
213                    java.lang.String uuid, int start, int end)
214                    throws com.liferay.portal.kernel.exception.SystemException {
215                    return getPersistence().findByUuid(uuid, start, end);
216            }
217    
218            /**
219            * Returns an ordered range of all the layouts where uuid = &#63;.
220            *
221            * <p>
222            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
223            * </p>
224            *
225            * @param uuid the uuid
226            * @param start the lower bound of the range of layouts
227            * @param end the upper bound of the range of layouts (not inclusive)
228            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
229            * @return the ordered range of matching layouts
230            * @throws SystemException if a system exception occurred
231            */
232            public static java.util.List<com.liferay.portal.model.Layout> findByUuid(
233                    java.lang.String uuid, int start, int end,
234                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
235                    throws com.liferay.portal.kernel.exception.SystemException {
236                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
237            }
238    
239            /**
240            * Returns the first layout in the ordered set where uuid = &#63;.
241            *
242            * @param uuid the uuid
243            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
244            * @return the first matching layout
245            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
246            * @throws SystemException if a system exception occurred
247            */
248            public static com.liferay.portal.model.Layout findByUuid_First(
249                    java.lang.String uuid,
250                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
251                    throws com.liferay.portal.NoSuchLayoutException,
252                            com.liferay.portal.kernel.exception.SystemException {
253                    return getPersistence().findByUuid_First(uuid, orderByComparator);
254            }
255    
256            /**
257            * Returns the first layout in the ordered set where uuid = &#63;.
258            *
259            * @param uuid the uuid
260            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
261            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
262            * @throws SystemException if a system exception occurred
263            */
264            public static com.liferay.portal.model.Layout fetchByUuid_First(
265                    java.lang.String uuid,
266                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
267                    throws com.liferay.portal.kernel.exception.SystemException {
268                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
269            }
270    
271            /**
272            * Returns the last layout in the ordered set where uuid = &#63;.
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 last layout in the ordered set where uuid = &#63;.
290            *
291            * @param uuid the uuid
292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
293            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portal.model.Layout fetchByUuid_Last(
297                    java.lang.String uuid,
298                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
299                    throws com.liferay.portal.kernel.exception.SystemException {
300                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
301            }
302    
303            /**
304            * Returns the layouts before and after the current layout in the ordered set where uuid = &#63;.
305            *
306            * @param plid the primary key of the current layout
307            * @param uuid the uuid
308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
309            * @return the previous, current, and next layout
310            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
311            * @throws SystemException if a system exception occurred
312            */
313            public static com.liferay.portal.model.Layout[] findByUuid_PrevAndNext(
314                    long plid, java.lang.String uuid,
315                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
316                    throws com.liferay.portal.NoSuchLayoutException,
317                            com.liferay.portal.kernel.exception.SystemException {
318                    return getPersistence()
319                                       .findByUuid_PrevAndNext(plid, uuid, orderByComparator);
320            }
321    
322            /**
323            * Returns the layout where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
324            *
325            * @param uuid the uuid
326            * @param groupId the group ID
327            * @return the matching layout
328            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
329            * @throws SystemException if a system exception occurred
330            */
331            public static com.liferay.portal.model.Layout findByUUID_G(
332                    java.lang.String uuid, long groupId)
333                    throws com.liferay.portal.NoSuchLayoutException,
334                            com.liferay.portal.kernel.exception.SystemException {
335                    return getPersistence().findByUUID_G(uuid, groupId);
336            }
337    
338            /**
339            * Returns the layout where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
340            *
341            * @param uuid the uuid
342            * @param groupId the group ID
343            * @return the matching layout, or <code>null</code> if a matching layout could not be found
344            * @throws SystemException if a system exception occurred
345            */
346            public static com.liferay.portal.model.Layout fetchByUUID_G(
347                    java.lang.String uuid, long groupId)
348                    throws com.liferay.portal.kernel.exception.SystemException {
349                    return getPersistence().fetchByUUID_G(uuid, groupId);
350            }
351    
352            /**
353            * 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.
354            *
355            * @param uuid the uuid
356            * @param groupId the group ID
357            * @param retrieveFromCache whether to use the finder cache
358            * @return the matching layout, or <code>null</code> if a matching layout could not be found
359            * @throws SystemException if a system exception occurred
360            */
361            public static com.liferay.portal.model.Layout fetchByUUID_G(
362                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
363                    throws com.liferay.portal.kernel.exception.SystemException {
364                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
365            }
366    
367            /**
368            * Returns all the layouts where groupId = &#63;.
369            *
370            * @param groupId the group ID
371            * @return the matching layouts
372            * @throws SystemException if a system exception occurred
373            */
374            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
375                    long groupId)
376                    throws com.liferay.portal.kernel.exception.SystemException {
377                    return getPersistence().findByGroupId(groupId);
378            }
379    
380            /**
381            * Returns a range of all the layouts where groupId = &#63;.
382            *
383            * <p>
384            * 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.
385            * </p>
386            *
387            * @param groupId the group ID
388            * @param start the lower bound of the range of layouts
389            * @param end the upper bound of the range of layouts (not inclusive)
390            * @return the range of matching layouts
391            * @throws SystemException if a system exception occurred
392            */
393            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
394                    long groupId, int start, int end)
395                    throws com.liferay.portal.kernel.exception.SystemException {
396                    return getPersistence().findByGroupId(groupId, start, end);
397            }
398    
399            /**
400            * Returns an ordered range of all the layouts where groupId = &#63;.
401            *
402            * <p>
403            * 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.
404            * </p>
405            *
406            * @param groupId the group ID
407            * @param start the lower bound of the range of layouts
408            * @param end the upper bound of the range of layouts (not inclusive)
409            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
410            * @return the ordered range of matching layouts
411            * @throws SystemException if a system exception occurred
412            */
413            public static java.util.List<com.liferay.portal.model.Layout> findByGroupId(
414                    long groupId, int start, int end,
415                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
416                    throws com.liferay.portal.kernel.exception.SystemException {
417                    return getPersistence()
418                                       .findByGroupId(groupId, start, end, orderByComparator);
419            }
420    
421            /**
422            * Returns the first layout in the ordered set where groupId = &#63;.
423            *
424            * @param groupId the group ID
425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
426            * @return the first matching layout
427            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portal.model.Layout findByGroupId_First(
431                    long groupId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.NoSuchLayoutException,
434                            com.liferay.portal.kernel.exception.SystemException {
435                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
436            }
437    
438            /**
439            * Returns the first layout in the ordered set where groupId = &#63;.
440            *
441            * @param groupId the group ID
442            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
443            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
444            * @throws SystemException if a system exception occurred
445            */
446            public static com.liferay.portal.model.Layout fetchByGroupId_First(
447                    long groupId,
448                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
449                    throws com.liferay.portal.kernel.exception.SystemException {
450                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
451            }
452    
453            /**
454            * Returns the last layout in the ordered set where groupId = &#63;.
455            *
456            * @param groupId the group ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the last matching layout
459            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
460            * @throws SystemException if a system exception occurred
461            */
462            public static com.liferay.portal.model.Layout findByGroupId_Last(
463                    long groupId,
464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
465                    throws com.liferay.portal.NoSuchLayoutException,
466                            com.liferay.portal.kernel.exception.SystemException {
467                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
468            }
469    
470            /**
471            * Returns the last layout in the ordered set where groupId = &#63;.
472            *
473            * @param groupId the group ID
474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
475            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
476            * @throws SystemException if a system exception occurred
477            */
478            public static com.liferay.portal.model.Layout fetchByGroupId_Last(
479                    long groupId,
480                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
481                    throws com.liferay.portal.kernel.exception.SystemException {
482                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
483            }
484    
485            /**
486            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63;.
487            *
488            * @param plid the primary key of the current layout
489            * @param groupId the group ID
490            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
491            * @return the previous, current, and next layout
492            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
493            * @throws SystemException if a system exception occurred
494            */
495            public static com.liferay.portal.model.Layout[] findByGroupId_PrevAndNext(
496                    long plid, long groupId,
497                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
498                    throws com.liferay.portal.NoSuchLayoutException,
499                            com.liferay.portal.kernel.exception.SystemException {
500                    return getPersistence()
501                                       .findByGroupId_PrevAndNext(plid, groupId, orderByComparator);
502            }
503    
504            /**
505            * Returns all the layouts that the user has permission to view where groupId = &#63;.
506            *
507            * @param groupId the group ID
508            * @return the matching layouts that the user has permission to view
509            * @throws SystemException if a system exception occurred
510            */
511            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
512                    long groupId)
513                    throws com.liferay.portal.kernel.exception.SystemException {
514                    return getPersistence().filterFindByGroupId(groupId);
515            }
516    
517            /**
518            * Returns a range of all the layouts that the user has permission to view where groupId = &#63;.
519            *
520            * <p>
521            * 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.
522            * </p>
523            *
524            * @param groupId the group ID
525            * @param start the lower bound of the range of layouts
526            * @param end the upper bound of the range of layouts (not inclusive)
527            * @return the range of matching layouts that the user has permission to view
528            * @throws SystemException if a system exception occurred
529            */
530            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
531                    long groupId, int start, int end)
532                    throws com.liferay.portal.kernel.exception.SystemException {
533                    return getPersistence().filterFindByGroupId(groupId, start, end);
534            }
535    
536            /**
537            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63;.
538            *
539            * <p>
540            * 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.
541            * </p>
542            *
543            * @param groupId the group ID
544            * @param start the lower bound of the range of layouts
545            * @param end the upper bound of the range of layouts (not inclusive)
546            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
547            * @return the ordered range of matching layouts that the user has permission to view
548            * @throws SystemException if a system exception occurred
549            */
550            public static java.util.List<com.liferay.portal.model.Layout> filterFindByGroupId(
551                    long groupId, int start, int end,
552                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
553                    throws com.liferay.portal.kernel.exception.SystemException {
554                    return getPersistence()
555                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
556            }
557    
558            /**
559            * 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;.
560            *
561            * @param plid the primary key of the current layout
562            * @param groupId the group ID
563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
564            * @return the previous, current, and next layout
565            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
566            * @throws SystemException if a system exception occurred
567            */
568            public static com.liferay.portal.model.Layout[] filterFindByGroupId_PrevAndNext(
569                    long plid, long groupId,
570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
571                    throws com.liferay.portal.NoSuchLayoutException,
572                            com.liferay.portal.kernel.exception.SystemException {
573                    return getPersistence()
574                                       .filterFindByGroupId_PrevAndNext(plid, groupId,
575                            orderByComparator);
576            }
577    
578            /**
579            * Returns all the layouts where companyId = &#63;.
580            *
581            * @param companyId the company ID
582            * @return the matching layouts
583            * @throws SystemException if a system exception occurred
584            */
585            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
586                    long companyId)
587                    throws com.liferay.portal.kernel.exception.SystemException {
588                    return getPersistence().findByCompanyId(companyId);
589            }
590    
591            /**
592            * Returns a range of all the layouts where companyId = &#63;.
593            *
594            * <p>
595            * 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.
596            * </p>
597            *
598            * @param companyId the company ID
599            * @param start the lower bound of the range of layouts
600            * @param end the upper bound of the range of layouts (not inclusive)
601            * @return the range of matching layouts
602            * @throws SystemException if a system exception occurred
603            */
604            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
605                    long companyId, int start, int end)
606                    throws com.liferay.portal.kernel.exception.SystemException {
607                    return getPersistence().findByCompanyId(companyId, start, end);
608            }
609    
610            /**
611            * Returns an ordered range of all the layouts where companyId = &#63;.
612            *
613            * <p>
614            * 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.
615            * </p>
616            *
617            * @param companyId the company ID
618            * @param start the lower bound of the range of layouts
619            * @param end the upper bound of the range of layouts (not inclusive)
620            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
621            * @return the ordered range of matching layouts
622            * @throws SystemException if a system exception occurred
623            */
624            public static java.util.List<com.liferay.portal.model.Layout> findByCompanyId(
625                    long companyId, int start, int end,
626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
627                    throws com.liferay.portal.kernel.exception.SystemException {
628                    return getPersistence()
629                                       .findByCompanyId(companyId, start, end, orderByComparator);
630            }
631    
632            /**
633            * Returns the first layout in the ordered set where companyId = &#63;.
634            *
635            * @param companyId the company ID
636            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
637            * @return the first matching layout
638            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
639            * @throws SystemException if a system exception occurred
640            */
641            public static com.liferay.portal.model.Layout findByCompanyId_First(
642                    long companyId,
643                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
644                    throws com.liferay.portal.NoSuchLayoutException,
645                            com.liferay.portal.kernel.exception.SystemException {
646                    return getPersistence()
647                                       .findByCompanyId_First(companyId, orderByComparator);
648            }
649    
650            /**
651            * Returns the first layout in the ordered set where companyId = &#63;.
652            *
653            * @param companyId the company ID
654            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
655            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
656            * @throws SystemException if a system exception occurred
657            */
658            public static com.liferay.portal.model.Layout fetchByCompanyId_First(
659                    long companyId,
660                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
661                    throws com.liferay.portal.kernel.exception.SystemException {
662                    return getPersistence()
663                                       .fetchByCompanyId_First(companyId, orderByComparator);
664            }
665    
666            /**
667            * Returns the last layout in the ordered set where companyId = &#63;.
668            *
669            * @param companyId the company ID
670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
671            * @return the last matching layout
672            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
673            * @throws SystemException if a system exception occurred
674            */
675            public static com.liferay.portal.model.Layout findByCompanyId_Last(
676                    long companyId,
677                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
678                    throws com.liferay.portal.NoSuchLayoutException,
679                            com.liferay.portal.kernel.exception.SystemException {
680                    return getPersistence()
681                                       .findByCompanyId_Last(companyId, orderByComparator);
682            }
683    
684            /**
685            * Returns the last layout in the ordered set where companyId = &#63;.
686            *
687            * @param companyId the company ID
688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
689            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
690            * @throws SystemException if a system exception occurred
691            */
692            public static com.liferay.portal.model.Layout fetchByCompanyId_Last(
693                    long companyId,
694                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
695                    throws com.liferay.portal.kernel.exception.SystemException {
696                    return getPersistence()
697                                       .fetchByCompanyId_Last(companyId, orderByComparator);
698            }
699    
700            /**
701            * Returns the layouts before and after the current layout in the ordered set where companyId = &#63;.
702            *
703            * @param plid the primary key of the current layout
704            * @param companyId the company ID
705            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
706            * @return the previous, current, and next layout
707            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
708            * @throws SystemException if a system exception occurred
709            */
710            public static com.liferay.portal.model.Layout[] findByCompanyId_PrevAndNext(
711                    long plid, long companyId,
712                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
713                    throws com.liferay.portal.NoSuchLayoutException,
714                            com.liferay.portal.kernel.exception.SystemException {
715                    return getPersistence()
716                                       .findByCompanyId_PrevAndNext(plid, companyId,
717                            orderByComparator);
718            }
719    
720            /**
721            * Returns the layout where iconImageId = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
722            *
723            * @param iconImageId the icon image ID
724            * @return the matching layout
725            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
726            * @throws SystemException if a system exception occurred
727            */
728            public static com.liferay.portal.model.Layout findByIconImageId(
729                    long iconImageId)
730                    throws com.liferay.portal.NoSuchLayoutException,
731                            com.liferay.portal.kernel.exception.SystemException {
732                    return getPersistence().findByIconImageId(iconImageId);
733            }
734    
735            /**
736            * Returns the layout where iconImageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
737            *
738            * @param iconImageId the icon image ID
739            * @return the matching layout, or <code>null</code> if a matching layout could not be found
740            * @throws SystemException if a system exception occurred
741            */
742            public static com.liferay.portal.model.Layout fetchByIconImageId(
743                    long iconImageId)
744                    throws com.liferay.portal.kernel.exception.SystemException {
745                    return getPersistence().fetchByIconImageId(iconImageId);
746            }
747    
748            /**
749            * Returns the layout where iconImageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
750            *
751            * @param iconImageId the icon image ID
752            * @param retrieveFromCache whether to use the finder cache
753            * @return the matching layout, or <code>null</code> if a matching layout could not be found
754            * @throws SystemException if a system exception occurred
755            */
756            public static com.liferay.portal.model.Layout fetchByIconImageId(
757                    long iconImageId, boolean retrieveFromCache)
758                    throws com.liferay.portal.kernel.exception.SystemException {
759                    return getPersistence()
760                                       .fetchByIconImageId(iconImageId, retrieveFromCache);
761            }
762    
763            /**
764            * Returns all the layouts where layoutPrototypeUuid = &#63;.
765            *
766            * @param layoutPrototypeUuid the layout prototype uuid
767            * @return the matching layouts
768            * @throws SystemException if a system exception occurred
769            */
770            public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid(
771                    java.lang.String layoutPrototypeUuid)
772                    throws com.liferay.portal.kernel.exception.SystemException {
773                    return getPersistence().findByLayoutPrototypeUuid(layoutPrototypeUuid);
774            }
775    
776            /**
777            * Returns a range of all the layouts where layoutPrototypeUuid = &#63;.
778            *
779            * <p>
780            * 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.
781            * </p>
782            *
783            * @param layoutPrototypeUuid the layout prototype uuid
784            * @param start the lower bound of the range of layouts
785            * @param end the upper bound of the range of layouts (not inclusive)
786            * @return the range of matching layouts
787            * @throws SystemException if a system exception occurred
788            */
789            public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid(
790                    java.lang.String layoutPrototypeUuid, int start, int end)
791                    throws com.liferay.portal.kernel.exception.SystemException {
792                    return getPersistence()
793                                       .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end);
794            }
795    
796            /**
797            * Returns an ordered range of all the layouts where layoutPrototypeUuid = &#63;.
798            *
799            * <p>
800            * 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.
801            * </p>
802            *
803            * @param layoutPrototypeUuid the layout prototype uuid
804            * @param start the lower bound of the range of layouts
805            * @param end the upper bound of the range of layouts (not inclusive)
806            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
807            * @return the ordered range of matching layouts
808            * @throws SystemException if a system exception occurred
809            */
810            public static java.util.List<com.liferay.portal.model.Layout> findByLayoutPrototypeUuid(
811                    java.lang.String layoutPrototypeUuid, int start, int end,
812                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
813                    throws com.liferay.portal.kernel.exception.SystemException {
814                    return getPersistence()
815                                       .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end,
816                            orderByComparator);
817            }
818    
819            /**
820            * Returns the first layout in the ordered set where layoutPrototypeUuid = &#63;.
821            *
822            * @param layoutPrototypeUuid the layout prototype uuid
823            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
824            * @return the first matching layout
825            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
826            * @throws SystemException if a system exception occurred
827            */
828            public static com.liferay.portal.model.Layout findByLayoutPrototypeUuid_First(
829                    java.lang.String layoutPrototypeUuid,
830                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
831                    throws com.liferay.portal.NoSuchLayoutException,
832                            com.liferay.portal.kernel.exception.SystemException {
833                    return getPersistence()
834                                       .findByLayoutPrototypeUuid_First(layoutPrototypeUuid,
835                            orderByComparator);
836            }
837    
838            /**
839            * Returns the first layout in the ordered set where layoutPrototypeUuid = &#63;.
840            *
841            * @param layoutPrototypeUuid the layout prototype uuid
842            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
843            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
844            * @throws SystemException if a system exception occurred
845            */
846            public static com.liferay.portal.model.Layout fetchByLayoutPrototypeUuid_First(
847                    java.lang.String layoutPrototypeUuid,
848                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
849                    throws com.liferay.portal.kernel.exception.SystemException {
850                    return getPersistence()
851                                       .fetchByLayoutPrototypeUuid_First(layoutPrototypeUuid,
852                            orderByComparator);
853            }
854    
855            /**
856            * Returns the last layout in the ordered set where layoutPrototypeUuid = &#63;.
857            *
858            * @param layoutPrototypeUuid the layout prototype uuid
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the last matching layout
861            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
862            * @throws SystemException if a system exception occurred
863            */
864            public static com.liferay.portal.model.Layout findByLayoutPrototypeUuid_Last(
865                    java.lang.String layoutPrototypeUuid,
866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
867                    throws com.liferay.portal.NoSuchLayoutException,
868                            com.liferay.portal.kernel.exception.SystemException {
869                    return getPersistence()
870                                       .findByLayoutPrototypeUuid_Last(layoutPrototypeUuid,
871                            orderByComparator);
872            }
873    
874            /**
875            * Returns the last layout in the ordered set where layoutPrototypeUuid = &#63;.
876            *
877            * @param layoutPrototypeUuid the layout prototype uuid
878            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
879            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
880            * @throws SystemException if a system exception occurred
881            */
882            public static com.liferay.portal.model.Layout fetchByLayoutPrototypeUuid_Last(
883                    java.lang.String layoutPrototypeUuid,
884                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
885                    throws com.liferay.portal.kernel.exception.SystemException {
886                    return getPersistence()
887                                       .fetchByLayoutPrototypeUuid_Last(layoutPrototypeUuid,
888                            orderByComparator);
889            }
890    
891            /**
892            * Returns the layouts before and after the current layout in the ordered set where layoutPrototypeUuid = &#63;.
893            *
894            * @param plid the primary key of the current layout
895            * @param layoutPrototypeUuid the layout prototype uuid
896            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
897            * @return the previous, current, and next layout
898            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
899            * @throws SystemException if a system exception occurred
900            */
901            public static com.liferay.portal.model.Layout[] findByLayoutPrototypeUuid_PrevAndNext(
902                    long plid, java.lang.String layoutPrototypeUuid,
903                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
904                    throws com.liferay.portal.NoSuchLayoutException,
905                            com.liferay.portal.kernel.exception.SystemException {
906                    return getPersistence()
907                                       .findByLayoutPrototypeUuid_PrevAndNext(plid,
908                            layoutPrototypeUuid, orderByComparator);
909            }
910    
911            /**
912            * Returns all the layouts where groupId = &#63; and privateLayout = &#63;.
913            *
914            * @param groupId the group ID
915            * @param privateLayout the private layout
916            * @return the matching layouts
917            * @throws SystemException if a system exception occurred
918            */
919            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
920                    long groupId, boolean privateLayout)
921                    throws com.liferay.portal.kernel.exception.SystemException {
922                    return getPersistence().findByG_P(groupId, privateLayout);
923            }
924    
925            /**
926            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63;.
927            *
928            * <p>
929            * 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.
930            * </p>
931            *
932            * @param groupId the group ID
933            * @param privateLayout the private layout
934            * @param start the lower bound of the range of layouts
935            * @param end the upper bound of the range of layouts (not inclusive)
936            * @return the range of matching layouts
937            * @throws SystemException if a system exception occurred
938            */
939            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
940                    long groupId, boolean privateLayout, int start, int end)
941                    throws com.liferay.portal.kernel.exception.SystemException {
942                    return getPersistence().findByG_P(groupId, privateLayout, start, end);
943            }
944    
945            /**
946            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63;.
947            *
948            * <p>
949            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
950            * </p>
951            *
952            * @param groupId the group ID
953            * @param privateLayout the private layout
954            * @param start the lower bound of the range of layouts
955            * @param end the upper bound of the range of layouts (not inclusive)
956            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
957            * @return the ordered range of matching layouts
958            * @throws SystemException if a system exception occurred
959            */
960            public static java.util.List<com.liferay.portal.model.Layout> findByG_P(
961                    long groupId, boolean privateLayout, int start, int end,
962                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
963                    throws com.liferay.portal.kernel.exception.SystemException {
964                    return getPersistence()
965                                       .findByG_P(groupId, privateLayout, start, end,
966                            orderByComparator);
967            }
968    
969            /**
970            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
971            *
972            * @param groupId the group ID
973            * @param privateLayout the private layout
974            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
975            * @return the first matching layout
976            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
977            * @throws SystemException if a system exception occurred
978            */
979            public static com.liferay.portal.model.Layout findByG_P_First(
980                    long groupId, boolean privateLayout,
981                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
982                    throws com.liferay.portal.NoSuchLayoutException,
983                            com.liferay.portal.kernel.exception.SystemException {
984                    return getPersistence()
985                                       .findByG_P_First(groupId, privateLayout, orderByComparator);
986            }
987    
988            /**
989            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
990            *
991            * @param groupId the group ID
992            * @param privateLayout the private layout
993            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
994            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
995            * @throws SystemException if a system exception occurred
996            */
997            public static com.liferay.portal.model.Layout fetchByG_P_First(
998                    long groupId, boolean privateLayout,
999                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1000                    throws com.liferay.portal.kernel.exception.SystemException {
1001                    return getPersistence()
1002                                       .fetchByG_P_First(groupId, privateLayout, orderByComparator);
1003            }
1004    
1005            /**
1006            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1007            *
1008            * @param groupId the group ID
1009            * @param privateLayout the private layout
1010            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1011            * @return the last matching layout
1012            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1013            * @throws SystemException if a system exception occurred
1014            */
1015            public static com.liferay.portal.model.Layout findByG_P_Last(long groupId,
1016                    boolean privateLayout,
1017                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1018                    throws com.liferay.portal.NoSuchLayoutException,
1019                            com.liferay.portal.kernel.exception.SystemException {
1020                    return getPersistence()
1021                                       .findByG_P_Last(groupId, privateLayout, orderByComparator);
1022            }
1023    
1024            /**
1025            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1026            *
1027            * @param groupId the group ID
1028            * @param privateLayout the private layout
1029            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1030            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1031            * @throws SystemException if a system exception occurred
1032            */
1033            public static com.liferay.portal.model.Layout fetchByG_P_Last(
1034                    long groupId, boolean privateLayout,
1035                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1036                    throws com.liferay.portal.kernel.exception.SystemException {
1037                    return getPersistence()
1038                                       .fetchByG_P_Last(groupId, privateLayout, orderByComparator);
1039            }
1040    
1041            /**
1042            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63;.
1043            *
1044            * @param plid the primary key of the current layout
1045            * @param groupId the group ID
1046            * @param privateLayout the private layout
1047            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1048            * @return the previous, current, and next layout
1049            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1050            * @throws SystemException if a system exception occurred
1051            */
1052            public static com.liferay.portal.model.Layout[] findByG_P_PrevAndNext(
1053                    long plid, long groupId, boolean privateLayout,
1054                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1055                    throws com.liferay.portal.NoSuchLayoutException,
1056                            com.liferay.portal.kernel.exception.SystemException {
1057                    return getPersistence()
1058                                       .findByG_P_PrevAndNext(plid, groupId, privateLayout,
1059                            orderByComparator);
1060            }
1061    
1062            /**
1063            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
1064            *
1065            * @param groupId the group ID
1066            * @param privateLayout the private layout
1067            * @return the matching layouts that the user has permission to view
1068            * @throws SystemException if a system exception occurred
1069            */
1070            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
1071                    long groupId, boolean privateLayout)
1072                    throws com.liferay.portal.kernel.exception.SystemException {
1073                    return getPersistence().filterFindByG_P(groupId, privateLayout);
1074            }
1075    
1076            /**
1077            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
1078            *
1079            * <p>
1080            * 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.
1081            * </p>
1082            *
1083            * @param groupId the group ID
1084            * @param privateLayout the private layout
1085            * @param start the lower bound of the range of layouts
1086            * @param end the upper bound of the range of layouts (not inclusive)
1087            * @return the range of matching layouts that the user has permission to view
1088            * @throws SystemException if a system exception occurred
1089            */
1090            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
1091                    long groupId, boolean privateLayout, int start, int end)
1092                    throws com.liferay.portal.kernel.exception.SystemException {
1093                    return getPersistence()
1094                                       .filterFindByG_P(groupId, privateLayout, start, end);
1095            }
1096    
1097            /**
1098            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63;.
1099            *
1100            * <p>
1101            * 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.
1102            * </p>
1103            *
1104            * @param groupId the group ID
1105            * @param privateLayout the private layout
1106            * @param start the lower bound of the range of layouts
1107            * @param end the upper bound of the range of layouts (not inclusive)
1108            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1109            * @return the ordered range of matching layouts that the user has permission to view
1110            * @throws SystemException if a system exception occurred
1111            */
1112            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P(
1113                    long groupId, boolean privateLayout, int start, int end,
1114                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1115                    throws com.liferay.portal.kernel.exception.SystemException {
1116                    return getPersistence()
1117                                       .filterFindByG_P(groupId, privateLayout, start, end,
1118                            orderByComparator);
1119            }
1120    
1121            /**
1122            * 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;.
1123            *
1124            * @param plid the primary key of the current layout
1125            * @param groupId the group ID
1126            * @param privateLayout the private layout
1127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1128            * @return the previous, current, and next layout
1129            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1130            * @throws SystemException if a system exception occurred
1131            */
1132            public static com.liferay.portal.model.Layout[] filterFindByG_P_PrevAndNext(
1133                    long plid, long groupId, boolean privateLayout,
1134                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1135                    throws com.liferay.portal.NoSuchLayoutException,
1136                            com.liferay.portal.kernel.exception.SystemException {
1137                    return getPersistence()
1138                                       .filterFindByG_P_PrevAndNext(plid, groupId, privateLayout,
1139                            orderByComparator);
1140            }
1141    
1142            /**
1143            * 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.
1144            *
1145            * @param groupId the group ID
1146            * @param privateLayout the private layout
1147            * @param layoutId the layout ID
1148            * @return the matching layout
1149            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1150            * @throws SystemException if a system exception occurred
1151            */
1152            public static com.liferay.portal.model.Layout findByG_P_L(long groupId,
1153                    boolean privateLayout, long layoutId)
1154                    throws com.liferay.portal.NoSuchLayoutException,
1155                            com.liferay.portal.kernel.exception.SystemException {
1156                    return getPersistence().findByG_P_L(groupId, privateLayout, layoutId);
1157            }
1158    
1159            /**
1160            * 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.
1161            *
1162            * @param groupId the group ID
1163            * @param privateLayout the private layout
1164            * @param layoutId the layout ID
1165            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1166            * @throws SystemException if a system exception occurred
1167            */
1168            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1169                    boolean privateLayout, long layoutId)
1170                    throws com.liferay.portal.kernel.exception.SystemException {
1171                    return getPersistence().fetchByG_P_L(groupId, privateLayout, layoutId);
1172            }
1173    
1174            /**
1175            * 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.
1176            *
1177            * @param groupId the group ID
1178            * @param privateLayout the private layout
1179            * @param layoutId the layout ID
1180            * @param retrieveFromCache whether to use the finder cache
1181            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1182            * @throws SystemException if a system exception occurred
1183            */
1184            public static com.liferay.portal.model.Layout fetchByG_P_L(long groupId,
1185                    boolean privateLayout, long layoutId, boolean retrieveFromCache)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence()
1188                                       .fetchByG_P_L(groupId, privateLayout, layoutId,
1189                            retrieveFromCache);
1190            }
1191    
1192            /**
1193            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1194            *
1195            * @param groupId the group ID
1196            * @param privateLayout the private layout
1197            * @param parentLayoutId the parent layout ID
1198            * @return the matching layouts
1199            * @throws SystemException if a system exception occurred
1200            */
1201            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1202                    long groupId, boolean privateLayout, long parentLayoutId)
1203                    throws com.liferay.portal.kernel.exception.SystemException {
1204                    return getPersistence()
1205                                       .findByG_P_P(groupId, privateLayout, parentLayoutId);
1206            }
1207    
1208            /**
1209            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1210            *
1211            * <p>
1212            * 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.
1213            * </p>
1214            *
1215            * @param groupId the group ID
1216            * @param privateLayout the private layout
1217            * @param parentLayoutId the parent layout ID
1218            * @param start the lower bound of the range of layouts
1219            * @param end the upper bound of the range of layouts (not inclusive)
1220            * @return the range of matching layouts
1221            * @throws SystemException if a system exception occurred
1222            */
1223            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1224                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1225                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1226                    return getPersistence()
1227                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1228                            end);
1229            }
1230    
1231            /**
1232            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1233            *
1234            * <p>
1235            * 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.
1236            * </p>
1237            *
1238            * @param groupId the group ID
1239            * @param privateLayout the private layout
1240            * @param parentLayoutId the parent layout ID
1241            * @param start the lower bound of the range of layouts
1242            * @param end the upper bound of the range of layouts (not inclusive)
1243            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1244            * @return the ordered range of matching layouts
1245            * @throws SystemException if a system exception occurred
1246            */
1247            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_P(
1248                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1249                    int end,
1250                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1251                    throws com.liferay.portal.kernel.exception.SystemException {
1252                    return getPersistence()
1253                                       .findByG_P_P(groupId, privateLayout, parentLayoutId, start,
1254                            end, orderByComparator);
1255            }
1256    
1257            /**
1258            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1259            *
1260            * @param groupId the group ID
1261            * @param privateLayout the private layout
1262            * @param parentLayoutId the parent layout ID
1263            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1264            * @return the first matching layout
1265            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1266            * @throws SystemException if a system exception occurred
1267            */
1268            public static com.liferay.portal.model.Layout findByG_P_P_First(
1269                    long groupId, boolean privateLayout, long parentLayoutId,
1270                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1271                    throws com.liferay.portal.NoSuchLayoutException,
1272                            com.liferay.portal.kernel.exception.SystemException {
1273                    return getPersistence()
1274                                       .findByG_P_P_First(groupId, privateLayout, parentLayoutId,
1275                            orderByComparator);
1276            }
1277    
1278            /**
1279            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1280            *
1281            * @param groupId the group ID
1282            * @param privateLayout the private layout
1283            * @param parentLayoutId the parent layout ID
1284            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1285            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1286            * @throws SystemException if a system exception occurred
1287            */
1288            public static com.liferay.portal.model.Layout fetchByG_P_P_First(
1289                    long groupId, boolean privateLayout, long parentLayoutId,
1290                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1291                    throws com.liferay.portal.kernel.exception.SystemException {
1292                    return getPersistence()
1293                                       .fetchByG_P_P_First(groupId, privateLayout, parentLayoutId,
1294                            orderByComparator);
1295            }
1296    
1297            /**
1298            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1299            *
1300            * @param groupId the group ID
1301            * @param privateLayout the private layout
1302            * @param parentLayoutId the parent layout ID
1303            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1304            * @return the last matching layout
1305            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1306            * @throws SystemException if a system exception occurred
1307            */
1308            public static com.liferay.portal.model.Layout findByG_P_P_Last(
1309                    long groupId, boolean privateLayout, long parentLayoutId,
1310                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1311                    throws com.liferay.portal.NoSuchLayoutException,
1312                            com.liferay.portal.kernel.exception.SystemException {
1313                    return getPersistence()
1314                                       .findByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1315                            orderByComparator);
1316            }
1317    
1318            /**
1319            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1320            *
1321            * @param groupId the group ID
1322            * @param privateLayout the private layout
1323            * @param parentLayoutId the parent layout ID
1324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1325            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1326            * @throws SystemException if a system exception occurred
1327            */
1328            public static com.liferay.portal.model.Layout fetchByG_P_P_Last(
1329                    long groupId, boolean privateLayout, long parentLayoutId,
1330                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1331                    throws com.liferay.portal.kernel.exception.SystemException {
1332                    return getPersistence()
1333                                       .fetchByG_P_P_Last(groupId, privateLayout, parentLayoutId,
1334                            orderByComparator);
1335            }
1336    
1337            /**
1338            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1339            *
1340            * @param plid the primary key of the current layout
1341            * @param groupId the group ID
1342            * @param privateLayout the private layout
1343            * @param parentLayoutId the parent layout ID
1344            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1345            * @return the previous, current, and next layout
1346            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1347            * @throws SystemException if a system exception occurred
1348            */
1349            public static com.liferay.portal.model.Layout[] findByG_P_P_PrevAndNext(
1350                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1351                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1352                    throws com.liferay.portal.NoSuchLayoutException,
1353                            com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence()
1355                                       .findByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1356                            parentLayoutId, orderByComparator);
1357            }
1358    
1359            /**
1360            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1361            *
1362            * @param groupId the group ID
1363            * @param privateLayout the private layout
1364            * @param parentLayoutId the parent layout ID
1365            * @return the matching layouts that the user has permission to view
1366            * @throws SystemException if a system exception occurred
1367            */
1368            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1369                    long groupId, boolean privateLayout, long parentLayoutId)
1370                    throws com.liferay.portal.kernel.exception.SystemException {
1371                    return getPersistence()
1372                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId);
1373            }
1374    
1375            /**
1376            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1377            *
1378            * <p>
1379            * 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.
1380            * </p>
1381            *
1382            * @param groupId the group ID
1383            * @param privateLayout the private layout
1384            * @param parentLayoutId the parent layout ID
1385            * @param start the lower bound of the range of layouts
1386            * @param end the upper bound of the range of layouts (not inclusive)
1387            * @return the range of matching layouts that the user has permission to view
1388            * @throws SystemException if a system exception occurred
1389            */
1390            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1391                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1392                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1393                    return getPersistence()
1394                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1395                            start, end);
1396            }
1397    
1398            /**
1399            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
1400            *
1401            * <p>
1402            * 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.
1403            * </p>
1404            *
1405            * @param groupId the group ID
1406            * @param privateLayout the private layout
1407            * @param parentLayoutId the parent layout ID
1408            * @param start the lower bound of the range of layouts
1409            * @param end the upper bound of the range of layouts (not inclusive)
1410            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1411            * @return the ordered range of matching layouts that the user has permission to view
1412            * @throws SystemException if a system exception occurred
1413            */
1414            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_P(
1415                    long groupId, boolean privateLayout, long parentLayoutId, int start,
1416                    int end,
1417                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1418                    throws com.liferay.portal.kernel.exception.SystemException {
1419                    return getPersistence()
1420                                       .filterFindByG_P_P(groupId, privateLayout, parentLayoutId,
1421                            start, end, orderByComparator);
1422            }
1423    
1424            /**
1425            * 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;.
1426            *
1427            * @param plid the primary key of the current layout
1428            * @param groupId the group ID
1429            * @param privateLayout the private layout
1430            * @param parentLayoutId the parent layout ID
1431            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1432            * @return the previous, current, and next layout
1433            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1434            * @throws SystemException if a system exception occurred
1435            */
1436            public static com.liferay.portal.model.Layout[] filterFindByG_P_P_PrevAndNext(
1437                    long plid, long groupId, boolean privateLayout, long parentLayoutId,
1438                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1439                    throws com.liferay.portal.NoSuchLayoutException,
1440                            com.liferay.portal.kernel.exception.SystemException {
1441                    return getPersistence()
1442                                       .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout,
1443                            parentLayoutId, orderByComparator);
1444            }
1445    
1446            /**
1447            * 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.
1448            *
1449            * @param groupId the group ID
1450            * @param privateLayout the private layout
1451            * @param friendlyURL the friendly u r l
1452            * @return the matching layout
1453            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1454            * @throws SystemException if a system exception occurred
1455            */
1456            public static com.liferay.portal.model.Layout findByG_P_F(long groupId,
1457                    boolean privateLayout, java.lang.String friendlyURL)
1458                    throws com.liferay.portal.NoSuchLayoutException,
1459                            com.liferay.portal.kernel.exception.SystemException {
1460                    return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL);
1461            }
1462    
1463            /**
1464            * 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.
1465            *
1466            * @param groupId the group ID
1467            * @param privateLayout the private layout
1468            * @param friendlyURL the friendly u r l
1469            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1470            * @throws SystemException if a system exception occurred
1471            */
1472            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1473                    boolean privateLayout, java.lang.String friendlyURL)
1474                    throws com.liferay.portal.kernel.exception.SystemException {
1475                    return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL);
1476            }
1477    
1478            /**
1479            * 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.
1480            *
1481            * @param groupId the group ID
1482            * @param privateLayout the private layout
1483            * @param friendlyURL the friendly u r l
1484            * @param retrieveFromCache whether to use the finder cache
1485            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1486            * @throws SystemException if a system exception occurred
1487            */
1488            public static com.liferay.portal.model.Layout fetchByG_P_F(long groupId,
1489                    boolean privateLayout, java.lang.String friendlyURL,
1490                    boolean retrieveFromCache)
1491                    throws com.liferay.portal.kernel.exception.SystemException {
1492                    return getPersistence()
1493                                       .fetchByG_P_F(groupId, privateLayout, friendlyURL,
1494                            retrieveFromCache);
1495            }
1496    
1497            /**
1498            * Returns all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1499            *
1500            * @param groupId the group ID
1501            * @param privateLayout the private layout
1502            * @param type the type
1503            * @return the matching layouts
1504            * @throws SystemException if a system exception occurred
1505            */
1506            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
1507                    long groupId, boolean privateLayout, java.lang.String type)
1508                    throws com.liferay.portal.kernel.exception.SystemException {
1509                    return getPersistence().findByG_P_T(groupId, privateLayout, type);
1510            }
1511    
1512            /**
1513            * Returns a range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1514            *
1515            * <p>
1516            * 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.
1517            * </p>
1518            *
1519            * @param groupId the group ID
1520            * @param privateLayout the private layout
1521            * @param type the type
1522            * @param start the lower bound of the range of layouts
1523            * @param end the upper bound of the range of layouts (not inclusive)
1524            * @return the range of matching layouts
1525            * @throws SystemException if a system exception occurred
1526            */
1527            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
1528                    long groupId, boolean privateLayout, java.lang.String type, int start,
1529                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1530                    return getPersistence()
1531                                       .findByG_P_T(groupId, privateLayout, type, start, end);
1532            }
1533    
1534            /**
1535            * Returns an ordered range of all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1536            *
1537            * <p>
1538            * 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.
1539            * </p>
1540            *
1541            * @param groupId the group ID
1542            * @param privateLayout the private layout
1543            * @param type the type
1544            * @param start the lower bound of the range of layouts
1545            * @param end the upper bound of the range of layouts (not inclusive)
1546            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1547            * @return the ordered range of matching layouts
1548            * @throws SystemException if a system exception occurred
1549            */
1550            public static java.util.List<com.liferay.portal.model.Layout> findByG_P_T(
1551                    long groupId, boolean privateLayout, java.lang.String type, int start,
1552                    int end,
1553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence()
1556                                       .findByG_P_T(groupId, privateLayout, type, start, end,
1557                            orderByComparator);
1558            }
1559    
1560            /**
1561            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1562            *
1563            * @param groupId the group ID
1564            * @param privateLayout the private layout
1565            * @param type the type
1566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1567            * @return the first matching layout
1568            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1569            * @throws SystemException if a system exception occurred
1570            */
1571            public static com.liferay.portal.model.Layout findByG_P_T_First(
1572                    long groupId, boolean privateLayout, java.lang.String type,
1573                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1574                    throws com.liferay.portal.NoSuchLayoutException,
1575                            com.liferay.portal.kernel.exception.SystemException {
1576                    return getPersistence()
1577                                       .findByG_P_T_First(groupId, privateLayout, type,
1578                            orderByComparator);
1579            }
1580    
1581            /**
1582            * Returns the first layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1583            *
1584            * @param groupId the group ID
1585            * @param privateLayout the private layout
1586            * @param type the type
1587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1588            * @return the first matching layout, or <code>null</code> if a matching layout could not be found
1589            * @throws SystemException if a system exception occurred
1590            */
1591            public static com.liferay.portal.model.Layout fetchByG_P_T_First(
1592                    long groupId, boolean privateLayout, java.lang.String type,
1593                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1594                    throws com.liferay.portal.kernel.exception.SystemException {
1595                    return getPersistence()
1596                                       .fetchByG_P_T_First(groupId, privateLayout, type,
1597                            orderByComparator);
1598            }
1599    
1600            /**
1601            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1602            *
1603            * @param groupId the group ID
1604            * @param privateLayout the private layout
1605            * @param type the type
1606            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1607            * @return the last matching layout
1608            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1609            * @throws SystemException if a system exception occurred
1610            */
1611            public static com.liferay.portal.model.Layout findByG_P_T_Last(
1612                    long groupId, boolean privateLayout, java.lang.String type,
1613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1614                    throws com.liferay.portal.NoSuchLayoutException,
1615                            com.liferay.portal.kernel.exception.SystemException {
1616                    return getPersistence()
1617                                       .findByG_P_T_Last(groupId, privateLayout, type,
1618                            orderByComparator);
1619            }
1620    
1621            /**
1622            * Returns the last layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1623            *
1624            * @param groupId the group ID
1625            * @param privateLayout the private layout
1626            * @param type the type
1627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1628            * @return the last matching layout, or <code>null</code> if a matching layout could not be found
1629            * @throws SystemException if a system exception occurred
1630            */
1631            public static com.liferay.portal.model.Layout fetchByG_P_T_Last(
1632                    long groupId, boolean privateLayout, java.lang.String type,
1633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1634                    throws com.liferay.portal.kernel.exception.SystemException {
1635                    return getPersistence()
1636                                       .fetchByG_P_T_Last(groupId, privateLayout, type,
1637                            orderByComparator);
1638            }
1639    
1640            /**
1641            * Returns the layouts before and after the current layout in the ordered set where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1642            *
1643            * @param plid the primary key of the current layout
1644            * @param groupId the group ID
1645            * @param privateLayout the private layout
1646            * @param type the type
1647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1648            * @return the previous, current, and next layout
1649            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1650            * @throws SystemException if a system exception occurred
1651            */
1652            public static com.liferay.portal.model.Layout[] findByG_P_T_PrevAndNext(
1653                    long plid, long groupId, boolean privateLayout, java.lang.String type,
1654                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1655                    throws com.liferay.portal.NoSuchLayoutException,
1656                            com.liferay.portal.kernel.exception.SystemException {
1657                    return getPersistence()
1658                                       .findByG_P_T_PrevAndNext(plid, groupId, privateLayout, type,
1659                            orderByComparator);
1660            }
1661    
1662            /**
1663            * Returns all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1664            *
1665            * @param groupId the group ID
1666            * @param privateLayout the private layout
1667            * @param type the type
1668            * @return the matching layouts that the user has permission to view
1669            * @throws SystemException if a system exception occurred
1670            */
1671            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
1672                    long groupId, boolean privateLayout, java.lang.String type)
1673                    throws com.liferay.portal.kernel.exception.SystemException {
1674                    return getPersistence().filterFindByG_P_T(groupId, privateLayout, type);
1675            }
1676    
1677            /**
1678            * Returns a range of all the layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1679            *
1680            * <p>
1681            * 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.
1682            * </p>
1683            *
1684            * @param groupId the group ID
1685            * @param privateLayout the private layout
1686            * @param type the type
1687            * @param start the lower bound of the range of layouts
1688            * @param end the upper bound of the range of layouts (not inclusive)
1689            * @return the range of matching layouts that the user has permission to view
1690            * @throws SystemException if a system exception occurred
1691            */
1692            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
1693                    long groupId, boolean privateLayout, java.lang.String type, int start,
1694                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1695                    return getPersistence()
1696                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end);
1697            }
1698    
1699            /**
1700            * Returns an ordered range of all the layouts that the user has permissions to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
1701            *
1702            * <p>
1703            * 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.
1704            * </p>
1705            *
1706            * @param groupId the group ID
1707            * @param privateLayout the private layout
1708            * @param type the type
1709            * @param start the lower bound of the range of layouts
1710            * @param end the upper bound of the range of layouts (not inclusive)
1711            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1712            * @return the ordered range of matching layouts that the user has permission to view
1713            * @throws SystemException if a system exception occurred
1714            */
1715            public static java.util.List<com.liferay.portal.model.Layout> filterFindByG_P_T(
1716                    long groupId, boolean privateLayout, java.lang.String type, int start,
1717                    int end,
1718                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1719                    throws com.liferay.portal.kernel.exception.SystemException {
1720                    return getPersistence()
1721                                       .filterFindByG_P_T(groupId, privateLayout, type, start, end,
1722                            orderByComparator);
1723            }
1724    
1725            /**
1726            * 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;.
1727            *
1728            * @param plid the primary key of the current layout
1729            * @param groupId the group ID
1730            * @param privateLayout the private layout
1731            * @param type the type
1732            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1733            * @return the previous, current, and next layout
1734            * @throws com.liferay.portal.NoSuchLayoutException if a layout with the primary key could not be found
1735            * @throws SystemException if a system exception occurred
1736            */
1737            public static com.liferay.portal.model.Layout[] filterFindByG_P_T_PrevAndNext(
1738                    long plid, long groupId, boolean privateLayout, java.lang.String type,
1739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1740                    throws com.liferay.portal.NoSuchLayoutException,
1741                            com.liferay.portal.kernel.exception.SystemException {
1742                    return getPersistence()
1743                                       .filterFindByG_P_T_PrevAndNext(plid, groupId, privateLayout,
1744                            type, orderByComparator);
1745            }
1746    
1747            /**
1748            * Returns the layout where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63; or throws a {@link com.liferay.portal.NoSuchLayoutException} if it could not be found.
1749            *
1750            * @param groupId the group ID
1751            * @param privateLayout the private layout
1752            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1753            * @return the matching layout
1754            * @throws com.liferay.portal.NoSuchLayoutException if a matching layout could not be found
1755            * @throws SystemException if a system exception occurred
1756            */
1757            public static com.liferay.portal.model.Layout findByG_P_SPLU(long groupId,
1758                    boolean privateLayout, java.lang.String sourcePrototypeLayoutUuid)
1759                    throws com.liferay.portal.NoSuchLayoutException,
1760                            com.liferay.portal.kernel.exception.SystemException {
1761                    return getPersistence()
1762                                       .findByG_P_SPLU(groupId, privateLayout,
1763                            sourcePrototypeLayoutUuid);
1764            }
1765    
1766            /**
1767            * Returns the layout where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1768            *
1769            * @param groupId the group ID
1770            * @param privateLayout the private layout
1771            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1772            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1773            * @throws SystemException if a system exception occurred
1774            */
1775            public static com.liferay.portal.model.Layout fetchByG_P_SPLU(
1776                    long groupId, boolean privateLayout,
1777                    java.lang.String sourcePrototypeLayoutUuid)
1778                    throws com.liferay.portal.kernel.exception.SystemException {
1779                    return getPersistence()
1780                                       .fetchByG_P_SPLU(groupId, privateLayout,
1781                            sourcePrototypeLayoutUuid);
1782            }
1783    
1784            /**
1785            * Returns the layout where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1786            *
1787            * @param groupId the group ID
1788            * @param privateLayout the private layout
1789            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
1790            * @param retrieveFromCache whether to use the finder cache
1791            * @return the matching layout, or <code>null</code> if a matching layout could not be found
1792            * @throws SystemException if a system exception occurred
1793            */
1794            public static com.liferay.portal.model.Layout fetchByG_P_SPLU(
1795                    long groupId, boolean privateLayout,
1796                    java.lang.String sourcePrototypeLayoutUuid, boolean retrieveFromCache)
1797                    throws com.liferay.portal.kernel.exception.SystemException {
1798                    return getPersistence()
1799                                       .fetchByG_P_SPLU(groupId, privateLayout,
1800                            sourcePrototypeLayoutUuid, retrieveFromCache);
1801            }
1802    
1803            /**
1804            * Returns all the layouts.
1805            *
1806            * @return the layouts
1807            * @throws SystemException if a system exception occurred
1808            */
1809            public static java.util.List<com.liferay.portal.model.Layout> findAll()
1810                    throws com.liferay.portal.kernel.exception.SystemException {
1811                    return getPersistence().findAll();
1812            }
1813    
1814            /**
1815            * Returns a range of all the layouts.
1816            *
1817            * <p>
1818            * 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.
1819            * </p>
1820            *
1821            * @param start the lower bound of the range of layouts
1822            * @param end the upper bound of the range of layouts (not inclusive)
1823            * @return the range of layouts
1824            * @throws SystemException if a system exception occurred
1825            */
1826            public static java.util.List<com.liferay.portal.model.Layout> findAll(
1827                    int start, int end)
1828                    throws com.liferay.portal.kernel.exception.SystemException {
1829                    return getPersistence().findAll(start, end);
1830            }
1831    
1832            /**
1833            * Returns an ordered range of all the layouts.
1834            *
1835            * <p>
1836            * 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.
1837            * </p>
1838            *
1839            * @param start the lower bound of the range of layouts
1840            * @param end the upper bound of the range of layouts (not inclusive)
1841            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1842            * @return the ordered range of layouts
1843            * @throws SystemException if a system exception occurred
1844            */
1845            public static java.util.List<com.liferay.portal.model.Layout> findAll(
1846                    int start, int end,
1847                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1848                    throws com.liferay.portal.kernel.exception.SystemException {
1849                    return getPersistence().findAll(start, end, orderByComparator);
1850            }
1851    
1852            /**
1853            * Removes all the layouts where uuid = &#63; from the database.
1854            *
1855            * @param uuid the uuid
1856            * @throws SystemException if a system exception occurred
1857            */
1858            public static void removeByUuid(java.lang.String uuid)
1859                    throws com.liferay.portal.kernel.exception.SystemException {
1860                    getPersistence().removeByUuid(uuid);
1861            }
1862    
1863            /**
1864            * Removes the layout where uuid = &#63; and groupId = &#63; from the database.
1865            *
1866            * @param uuid the uuid
1867            * @param groupId the group ID
1868            * @return the layout that was removed
1869            * @throws SystemException if a system exception occurred
1870            */
1871            public static com.liferay.portal.model.Layout removeByUUID_G(
1872                    java.lang.String uuid, long groupId)
1873                    throws com.liferay.portal.NoSuchLayoutException,
1874                            com.liferay.portal.kernel.exception.SystemException {
1875                    return getPersistence().removeByUUID_G(uuid, groupId);
1876            }
1877    
1878            /**
1879            * Removes all the layouts where groupId = &#63; from the database.
1880            *
1881            * @param groupId the group ID
1882            * @throws SystemException if a system exception occurred
1883            */
1884            public static void removeByGroupId(long groupId)
1885                    throws com.liferay.portal.kernel.exception.SystemException {
1886                    getPersistence().removeByGroupId(groupId);
1887            }
1888    
1889            /**
1890            * Removes all the layouts where companyId = &#63; from the database.
1891            *
1892            * @param companyId the company ID
1893            * @throws SystemException if a system exception occurred
1894            */
1895            public static void removeByCompanyId(long companyId)
1896                    throws com.liferay.portal.kernel.exception.SystemException {
1897                    getPersistence().removeByCompanyId(companyId);
1898            }
1899    
1900            /**
1901            * Removes the layout where iconImageId = &#63; from the database.
1902            *
1903            * @param iconImageId the icon image ID
1904            * @return the layout that was removed
1905            * @throws SystemException if a system exception occurred
1906            */
1907            public static com.liferay.portal.model.Layout removeByIconImageId(
1908                    long iconImageId)
1909                    throws com.liferay.portal.NoSuchLayoutException,
1910                            com.liferay.portal.kernel.exception.SystemException {
1911                    return getPersistence().removeByIconImageId(iconImageId);
1912            }
1913    
1914            /**
1915            * Removes all the layouts where layoutPrototypeUuid = &#63; from the database.
1916            *
1917            * @param layoutPrototypeUuid the layout prototype uuid
1918            * @throws SystemException if a system exception occurred
1919            */
1920            public static void removeByLayoutPrototypeUuid(
1921                    java.lang.String layoutPrototypeUuid)
1922                    throws com.liferay.portal.kernel.exception.SystemException {
1923                    getPersistence().removeByLayoutPrototypeUuid(layoutPrototypeUuid);
1924            }
1925    
1926            /**
1927            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; from the database.
1928            *
1929            * @param groupId the group ID
1930            * @param privateLayout the private layout
1931            * @throws SystemException if a system exception occurred
1932            */
1933            public static void removeByG_P(long groupId, boolean privateLayout)
1934                    throws com.liferay.portal.kernel.exception.SystemException {
1935                    getPersistence().removeByG_P(groupId, privateLayout);
1936            }
1937    
1938            /**
1939            * Removes the layout where groupId = &#63; and privateLayout = &#63; and layoutId = &#63; from the database.
1940            *
1941            * @param groupId the group ID
1942            * @param privateLayout the private layout
1943            * @param layoutId the layout ID
1944            * @return the layout that was removed
1945            * @throws SystemException if a system exception occurred
1946            */
1947            public static com.liferay.portal.model.Layout removeByG_P_L(long groupId,
1948                    boolean privateLayout, long layoutId)
1949                    throws com.liferay.portal.NoSuchLayoutException,
1950                            com.liferay.portal.kernel.exception.SystemException {
1951                    return getPersistence().removeByG_P_L(groupId, privateLayout, layoutId);
1952            }
1953    
1954            /**
1955            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63; from the database.
1956            *
1957            * @param groupId the group ID
1958            * @param privateLayout the private layout
1959            * @param parentLayoutId the parent layout ID
1960            * @throws SystemException if a system exception occurred
1961            */
1962            public static void removeByG_P_P(long groupId, boolean privateLayout,
1963                    long parentLayoutId)
1964                    throws com.liferay.portal.kernel.exception.SystemException {
1965                    getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId);
1966            }
1967    
1968            /**
1969            * Removes the layout where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; from the database.
1970            *
1971            * @param groupId the group ID
1972            * @param privateLayout the private layout
1973            * @param friendlyURL the friendly u r l
1974            * @return the layout that was removed
1975            * @throws SystemException if a system exception occurred
1976            */
1977            public static com.liferay.portal.model.Layout removeByG_P_F(long groupId,
1978                    boolean privateLayout, java.lang.String friendlyURL)
1979                    throws com.liferay.portal.NoSuchLayoutException,
1980                            com.liferay.portal.kernel.exception.SystemException {
1981                    return getPersistence()
1982                                       .removeByG_P_F(groupId, privateLayout, friendlyURL);
1983            }
1984    
1985            /**
1986            * Removes all the layouts where groupId = &#63; and privateLayout = &#63; and type = &#63; from the database.
1987            *
1988            * @param groupId the group ID
1989            * @param privateLayout the private layout
1990            * @param type the type
1991            * @throws SystemException if a system exception occurred
1992            */
1993            public static void removeByG_P_T(long groupId, boolean privateLayout,
1994                    java.lang.String type)
1995                    throws com.liferay.portal.kernel.exception.SystemException {
1996                    getPersistence().removeByG_P_T(groupId, privateLayout, type);
1997            }
1998    
1999            /**
2000            * Removes the layout where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63; from the database.
2001            *
2002            * @param groupId the group ID
2003            * @param privateLayout the private layout
2004            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2005            * @return the layout that was removed
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static com.liferay.portal.model.Layout removeByG_P_SPLU(
2009                    long groupId, boolean privateLayout,
2010                    java.lang.String sourcePrototypeLayoutUuid)
2011                    throws com.liferay.portal.NoSuchLayoutException,
2012                            com.liferay.portal.kernel.exception.SystemException {
2013                    return getPersistence()
2014                                       .removeByG_P_SPLU(groupId, privateLayout,
2015                            sourcePrototypeLayoutUuid);
2016            }
2017    
2018            /**
2019            * Removes all the layouts from the database.
2020            *
2021            * @throws SystemException if a system exception occurred
2022            */
2023            public static void removeAll()
2024                    throws com.liferay.portal.kernel.exception.SystemException {
2025                    getPersistence().removeAll();
2026            }
2027    
2028            /**
2029            * Returns the number of layouts where uuid = &#63;.
2030            *
2031            * @param uuid the uuid
2032            * @return the number of matching layouts
2033            * @throws SystemException if a system exception occurred
2034            */
2035            public static int countByUuid(java.lang.String uuid)
2036                    throws com.liferay.portal.kernel.exception.SystemException {
2037                    return getPersistence().countByUuid(uuid);
2038            }
2039    
2040            /**
2041            * Returns the number of layouts where uuid = &#63; and groupId = &#63;.
2042            *
2043            * @param uuid the uuid
2044            * @param groupId the group ID
2045            * @return the number of matching layouts
2046            * @throws SystemException if a system exception occurred
2047            */
2048            public static int countByUUID_G(java.lang.String uuid, long groupId)
2049                    throws com.liferay.portal.kernel.exception.SystemException {
2050                    return getPersistence().countByUUID_G(uuid, groupId);
2051            }
2052    
2053            /**
2054            * Returns the number of layouts where groupId = &#63;.
2055            *
2056            * @param groupId the group ID
2057            * @return the number of matching layouts
2058            * @throws SystemException if a system exception occurred
2059            */
2060            public static int countByGroupId(long groupId)
2061                    throws com.liferay.portal.kernel.exception.SystemException {
2062                    return getPersistence().countByGroupId(groupId);
2063            }
2064    
2065            /**
2066            * Returns the number of layouts that the user has permission to view where groupId = &#63;.
2067            *
2068            * @param groupId the group ID
2069            * @return the number of matching layouts that the user has permission to view
2070            * @throws SystemException if a system exception occurred
2071            */
2072            public static int filterCountByGroupId(long groupId)
2073                    throws com.liferay.portal.kernel.exception.SystemException {
2074                    return getPersistence().filterCountByGroupId(groupId);
2075            }
2076    
2077            /**
2078            * Returns the number of layouts where companyId = &#63;.
2079            *
2080            * @param companyId the company ID
2081            * @return the number of matching layouts
2082            * @throws SystemException if a system exception occurred
2083            */
2084            public static int countByCompanyId(long companyId)
2085                    throws com.liferay.portal.kernel.exception.SystemException {
2086                    return getPersistence().countByCompanyId(companyId);
2087            }
2088    
2089            /**
2090            * Returns the number of layouts where iconImageId = &#63;.
2091            *
2092            * @param iconImageId the icon image ID
2093            * @return the number of matching layouts
2094            * @throws SystemException if a system exception occurred
2095            */
2096            public static int countByIconImageId(long iconImageId)
2097                    throws com.liferay.portal.kernel.exception.SystemException {
2098                    return getPersistence().countByIconImageId(iconImageId);
2099            }
2100    
2101            /**
2102            * Returns the number of layouts where layoutPrototypeUuid = &#63;.
2103            *
2104            * @param layoutPrototypeUuid the layout prototype uuid
2105            * @return the number of matching layouts
2106            * @throws SystemException if a system exception occurred
2107            */
2108            public static int countByLayoutPrototypeUuid(
2109                    java.lang.String layoutPrototypeUuid)
2110                    throws com.liferay.portal.kernel.exception.SystemException {
2111                    return getPersistence().countByLayoutPrototypeUuid(layoutPrototypeUuid);
2112            }
2113    
2114            /**
2115            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63;.
2116            *
2117            * @param groupId the group ID
2118            * @param privateLayout the private layout
2119            * @return the number of matching layouts
2120            * @throws SystemException if a system exception occurred
2121            */
2122            public static int countByG_P(long groupId, boolean privateLayout)
2123                    throws com.liferay.portal.kernel.exception.SystemException {
2124                    return getPersistence().countByG_P(groupId, privateLayout);
2125            }
2126    
2127            /**
2128            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63;.
2129            *
2130            * @param groupId the group ID
2131            * @param privateLayout the private layout
2132            * @return the number of matching layouts that the user has permission to view
2133            * @throws SystemException if a system exception occurred
2134            */
2135            public static int filterCountByG_P(long groupId, boolean privateLayout)
2136                    throws com.liferay.portal.kernel.exception.SystemException {
2137                    return getPersistence().filterCountByG_P(groupId, privateLayout);
2138            }
2139    
2140            /**
2141            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and layoutId = &#63;.
2142            *
2143            * @param groupId the group ID
2144            * @param privateLayout the private layout
2145            * @param layoutId the layout ID
2146            * @return the number of matching layouts
2147            * @throws SystemException if a system exception occurred
2148            */
2149            public static int countByG_P_L(long groupId, boolean privateLayout,
2150                    long layoutId)
2151                    throws com.liferay.portal.kernel.exception.SystemException {
2152                    return getPersistence().countByG_P_L(groupId, privateLayout, layoutId);
2153            }
2154    
2155            /**
2156            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2157            *
2158            * @param groupId the group ID
2159            * @param privateLayout the private layout
2160            * @param parentLayoutId the parent layout ID
2161            * @return the number of matching layouts
2162            * @throws SystemException if a system exception occurred
2163            */
2164            public static int countByG_P_P(long groupId, boolean privateLayout,
2165                    long parentLayoutId)
2166                    throws com.liferay.portal.kernel.exception.SystemException {
2167                    return getPersistence()
2168                                       .countByG_P_P(groupId, privateLayout, parentLayoutId);
2169            }
2170    
2171            /**
2172            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and parentLayoutId = &#63;.
2173            *
2174            * @param groupId the group ID
2175            * @param privateLayout the private layout
2176            * @param parentLayoutId the parent layout ID
2177            * @return the number of matching layouts that the user has permission to view
2178            * @throws SystemException if a system exception occurred
2179            */
2180            public static int filterCountByG_P_P(long groupId, boolean privateLayout,
2181                    long parentLayoutId)
2182                    throws com.liferay.portal.kernel.exception.SystemException {
2183                    return getPersistence()
2184                                       .filterCountByG_P_P(groupId, privateLayout, parentLayoutId);
2185            }
2186    
2187            /**
2188            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
2189            *
2190            * @param groupId the group ID
2191            * @param privateLayout the private layout
2192            * @param friendlyURL the friendly u r l
2193            * @return the number of matching layouts
2194            * @throws SystemException if a system exception occurred
2195            */
2196            public static int countByG_P_F(long groupId, boolean privateLayout,
2197                    java.lang.String friendlyURL)
2198                    throws com.liferay.portal.kernel.exception.SystemException {
2199                    return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL);
2200            }
2201    
2202            /**
2203            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2204            *
2205            * @param groupId the group ID
2206            * @param privateLayout the private layout
2207            * @param type the type
2208            * @return the number of matching layouts
2209            * @throws SystemException if a system exception occurred
2210            */
2211            public static int countByG_P_T(long groupId, boolean privateLayout,
2212                    java.lang.String type)
2213                    throws com.liferay.portal.kernel.exception.SystemException {
2214                    return getPersistence().countByG_P_T(groupId, privateLayout, type);
2215            }
2216    
2217            /**
2218            * Returns the number of layouts that the user has permission to view where groupId = &#63; and privateLayout = &#63; and type = &#63;.
2219            *
2220            * @param groupId the group ID
2221            * @param privateLayout the private layout
2222            * @param type the type
2223            * @return the number of matching layouts that the user has permission to view
2224            * @throws SystemException if a system exception occurred
2225            */
2226            public static int filterCountByG_P_T(long groupId, boolean privateLayout,
2227                    java.lang.String type)
2228                    throws com.liferay.portal.kernel.exception.SystemException {
2229                    return getPersistence().filterCountByG_P_T(groupId, privateLayout, type);
2230            }
2231    
2232            /**
2233            * Returns the number of layouts where groupId = &#63; and privateLayout = &#63; and sourcePrototypeLayoutUuid = &#63;.
2234            *
2235            * @param groupId the group ID
2236            * @param privateLayout the private layout
2237            * @param sourcePrototypeLayoutUuid the source prototype layout uuid
2238            * @return the number of matching layouts
2239            * @throws SystemException if a system exception occurred
2240            */
2241            public static int countByG_P_SPLU(long groupId, boolean privateLayout,
2242                    java.lang.String sourcePrototypeLayoutUuid)
2243                    throws com.liferay.portal.kernel.exception.SystemException {
2244                    return getPersistence()
2245                                       .countByG_P_SPLU(groupId, privateLayout,
2246                            sourcePrototypeLayoutUuid);
2247            }
2248    
2249            /**
2250            * Returns the number of layouts.
2251            *
2252            * @return the number of layouts
2253            * @throws SystemException if a system exception occurred
2254            */
2255            public static int countAll()
2256                    throws com.liferay.portal.kernel.exception.SystemException {
2257                    return getPersistence().countAll();
2258            }
2259    
2260            public static LayoutPersistence getPersistence() {
2261                    if (_persistence == null) {
2262                            _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName());
2263    
2264                            ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence");
2265                    }
2266    
2267                    return _persistence;
2268            }
2269    
2270            /**
2271             * @deprecated
2272             */
2273            public void setPersistence(LayoutPersistence persistence) {
2274            }
2275    
2276            private static LayoutPersistence _persistence;
2277    }