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