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