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