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