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.LayoutFriendlyURL;
020    
021    /**
022     * The persistence interface for the layout friendly u r l 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.LayoutFriendlyURLPersistenceImpl
030     * @see LayoutFriendlyURLUtil
031     * @generated
032     */
033    @ProviderType
034    public interface LayoutFriendlyURLPersistence extends BasePersistence<LayoutFriendlyURL> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link LayoutFriendlyURLUtil} to access the layout friendly u r l persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the layout friendly u r ls where uuid = &#63;.
043            *
044            * @param uuid the uuid
045            * @return the matching layout friendly u r ls
046            */
047            public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid);
048    
049            /**
050            * Returns a range of all the layout friendly u r ls 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 LayoutFriendlyURLModelImpl}. 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 layout friendly u r ls
058            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
059            * @return the range of matching layout friendly u r ls
060            */
061            public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid,
062                    int start, int end);
063    
064            /**
065            * Returns an ordered range of all the layout friendly u r ls 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 LayoutFriendlyURLModelImpl}. 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 layout friendly u r ls
073            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
075            * @return the ordered range of matching layout friendly u r ls
076            */
077            public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid,
078                    int start, int end,
079                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
080    
081            /**
082            * Returns an ordered range of all the layout friendly u r ls where uuid = &#63;.
083            *
084            * <p>
085            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
086            * </p>
087            *
088            * @param uuid the uuid
089            * @param start the lower bound of the range of layout friendly u r ls
090            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
091            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
092            * @param retrieveFromCache whether to retrieve from the finder cache
093            * @return the ordered range of matching layout friendly u r ls
094            */
095            public java.util.List<LayoutFriendlyURL> findByUuid(java.lang.String uuid,
096                    int start, int end,
097                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
098                    boolean retrieveFromCache);
099    
100            /**
101            * Returns the first layout friendly u r l in the ordered set where uuid = &#63;.
102            *
103            * @param uuid the uuid
104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
105            * @return the first matching layout friendly u r l
106            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
107            */
108            public LayoutFriendlyURL findByUuid_First(java.lang.String uuid,
109                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
110                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
111    
112            /**
113            * Returns the first layout friendly u r l in the ordered set where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
117            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
118            */
119            public LayoutFriendlyURL fetchByUuid_First(java.lang.String uuid,
120                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
121    
122            /**
123            * Returns the last layout friendly u r l in the ordered set where uuid = &#63;.
124            *
125            * @param uuid the uuid
126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
127            * @return the last matching layout friendly u r l
128            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
129            */
130            public LayoutFriendlyURL findByUuid_Last(java.lang.String uuid,
131                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
132                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
133    
134            /**
135            * Returns the last layout friendly u r l in the ordered set where uuid = &#63;.
136            *
137            * @param uuid the uuid
138            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
139            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
140            */
141            public LayoutFriendlyURL fetchByUuid_Last(java.lang.String uuid,
142                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
143    
144            /**
145            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = &#63;.
146            *
147            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
148            * @param uuid the uuid
149            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
150            * @return the previous, current, and next layout friendly u r l
151            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
152            */
153            public LayoutFriendlyURL[] findByUuid_PrevAndNext(
154                    long layoutFriendlyURLId, java.lang.String uuid,
155                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
156                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
157    
158            /**
159            * Removes all the layout friendly u r ls where uuid = &#63; from the database.
160            *
161            * @param uuid the uuid
162            */
163            public void removeByUuid(java.lang.String uuid);
164    
165            /**
166            * Returns the number of layout friendly u r ls where uuid = &#63;.
167            *
168            * @param uuid the uuid
169            * @return the number of matching layout friendly u r ls
170            */
171            public int countByUuid(java.lang.String uuid);
172    
173            /**
174            * Returns the layout friendly u r l where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found.
175            *
176            * @param uuid the uuid
177            * @param groupId the group ID
178            * @return the matching layout friendly u r l
179            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
180            */
181            public LayoutFriendlyURL findByUUID_G(java.lang.String uuid, long groupId)
182                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
183    
184            /**
185            * Returns the layout friendly u r l where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
186            *
187            * @param uuid the uuid
188            * @param groupId the group ID
189            * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
190            */
191            public LayoutFriendlyURL fetchByUUID_G(java.lang.String uuid, long groupId);
192    
193            /**
194            * Returns the layout friendly u r l where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
195            *
196            * @param uuid the uuid
197            * @param groupId the group ID
198            * @param retrieveFromCache whether to retrieve from the finder cache
199            * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
200            */
201            public LayoutFriendlyURL fetchByUUID_G(java.lang.String uuid, long groupId,
202                    boolean retrieveFromCache);
203    
204            /**
205            * Removes the layout friendly u r l where uuid = &#63; and groupId = &#63; from the database.
206            *
207            * @param uuid the uuid
208            * @param groupId the group ID
209            * @return the layout friendly u r l that was removed
210            */
211            public LayoutFriendlyURL removeByUUID_G(java.lang.String uuid, long groupId)
212                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
213    
214            /**
215            * Returns the number of layout friendly u r ls where uuid = &#63; and groupId = &#63;.
216            *
217            * @param uuid the uuid
218            * @param groupId the group ID
219            * @return the number of matching layout friendly u r ls
220            */
221            public int countByUUID_G(java.lang.String uuid, long groupId);
222    
223            /**
224            * Returns all the layout friendly u r ls where uuid = &#63; and companyId = &#63;.
225            *
226            * @param uuid the uuid
227            * @param companyId the company ID
228            * @return the matching layout friendly u r ls
229            */
230            public java.util.List<LayoutFriendlyURL> findByUuid_C(
231                    java.lang.String uuid, long companyId);
232    
233            /**
234            * Returns a range of all the layout friendly u r ls where uuid = &#63; and companyId = &#63;.
235            *
236            * <p>
237            * 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 LayoutFriendlyURLModelImpl}. 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.
238            * </p>
239            *
240            * @param uuid the uuid
241            * @param companyId the company ID
242            * @param start the lower bound of the range of layout friendly u r ls
243            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
244            * @return the range of matching layout friendly u r ls
245            */
246            public java.util.List<LayoutFriendlyURL> findByUuid_C(
247                    java.lang.String uuid, long companyId, int start, int end);
248    
249            /**
250            * Returns an ordered range of all the layout friendly u r ls where uuid = &#63; and companyId = &#63;.
251            *
252            * <p>
253            * 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 LayoutFriendlyURLModelImpl}. 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.
254            * </p>
255            *
256            * @param uuid the uuid
257            * @param companyId the company ID
258            * @param start the lower bound of the range of layout friendly u r ls
259            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
260            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
261            * @return the ordered range of matching layout friendly u r ls
262            */
263            public java.util.List<LayoutFriendlyURL> findByUuid_C(
264                    java.lang.String uuid, long companyId, int start, int end,
265                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
266    
267            /**
268            * Returns an ordered range of all the layout friendly u r ls where uuid = &#63; and companyId = &#63;.
269            *
270            * <p>
271            * 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 LayoutFriendlyURLModelImpl}. 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.
272            * </p>
273            *
274            * @param uuid the uuid
275            * @param companyId the company ID
276            * @param start the lower bound of the range of layout friendly u r ls
277            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
278            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
279            * @param retrieveFromCache whether to retrieve from the finder cache
280            * @return the ordered range of matching layout friendly u r ls
281            */
282            public java.util.List<LayoutFriendlyURL> findByUuid_C(
283                    java.lang.String uuid, long companyId, int start, int end,
284                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
285                    boolean retrieveFromCache);
286    
287            /**
288            * Returns the first layout friendly u r l in the ordered set where uuid = &#63; and companyId = &#63;.
289            *
290            * @param uuid the uuid
291            * @param companyId the company ID
292            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
293            * @return the first matching layout friendly u r l
294            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
295            */
296            public LayoutFriendlyURL findByUuid_C_First(java.lang.String uuid,
297                    long companyId,
298                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
299                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
300    
301            /**
302            * Returns the first layout friendly u r l in the ordered set where uuid = &#63; and companyId = &#63;.
303            *
304            * @param uuid the uuid
305            * @param companyId the company ID
306            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
307            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
308            */
309            public LayoutFriendlyURL fetchByUuid_C_First(java.lang.String uuid,
310                    long companyId,
311                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
312    
313            /**
314            * Returns the last layout friendly u r l in the ordered set where uuid = &#63; and companyId = &#63;.
315            *
316            * @param uuid the uuid
317            * @param companyId the company ID
318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
319            * @return the last matching layout friendly u r l
320            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
321            */
322            public LayoutFriendlyURL findByUuid_C_Last(java.lang.String uuid,
323                    long companyId,
324                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
325                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
326    
327            /**
328            * Returns the last layout friendly u r l in the ordered set where uuid = &#63; and companyId = &#63;.
329            *
330            * @param uuid the uuid
331            * @param companyId the company ID
332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
333            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
334            */
335            public LayoutFriendlyURL fetchByUuid_C_Last(java.lang.String uuid,
336                    long companyId,
337                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
338    
339            /**
340            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = &#63; and companyId = &#63;.
341            *
342            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
343            * @param uuid the uuid
344            * @param companyId the company ID
345            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
346            * @return the previous, current, and next layout friendly u r l
347            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
348            */
349            public LayoutFriendlyURL[] findByUuid_C_PrevAndNext(
350                    long layoutFriendlyURLId, java.lang.String uuid, long companyId,
351                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
352                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
353    
354            /**
355            * Removes all the layout friendly u r ls where uuid = &#63; and companyId = &#63; from the database.
356            *
357            * @param uuid the uuid
358            * @param companyId the company ID
359            */
360            public void removeByUuid_C(java.lang.String uuid, long companyId);
361    
362            /**
363            * Returns the number of layout friendly u r ls where uuid = &#63; and companyId = &#63;.
364            *
365            * @param uuid the uuid
366            * @param companyId the company ID
367            * @return the number of matching layout friendly u r ls
368            */
369            public int countByUuid_C(java.lang.String uuid, long companyId);
370    
371            /**
372            * Returns all the layout friendly u r ls where groupId = &#63;.
373            *
374            * @param groupId the group ID
375            * @return the matching layout friendly u r ls
376            */
377            public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId);
378    
379            /**
380            * Returns a range of all the layout friendly u r ls where groupId = &#63;.
381            *
382            * <p>
383            * 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 LayoutFriendlyURLModelImpl}. 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.
384            * </p>
385            *
386            * @param groupId the group ID
387            * @param start the lower bound of the range of layout friendly u r ls
388            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
389            * @return the range of matching layout friendly u r ls
390            */
391            public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId,
392                    int start, int end);
393    
394            /**
395            * Returns an ordered range of all the layout friendly u r ls where groupId = &#63;.
396            *
397            * <p>
398            * 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 LayoutFriendlyURLModelImpl}. 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.
399            * </p>
400            *
401            * @param groupId the group ID
402            * @param start the lower bound of the range of layout friendly u r ls
403            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
404            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
405            * @return the ordered range of matching layout friendly u r ls
406            */
407            public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId,
408                    int start, int end,
409                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
410    
411            /**
412            * Returns an ordered range of all the layout friendly u r ls where groupId = &#63;.
413            *
414            * <p>
415            * 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 LayoutFriendlyURLModelImpl}. 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.
416            * </p>
417            *
418            * @param groupId the group ID
419            * @param start the lower bound of the range of layout friendly u r ls
420            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
421            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
422            * @param retrieveFromCache whether to retrieve from the finder cache
423            * @return the ordered range of matching layout friendly u r ls
424            */
425            public java.util.List<LayoutFriendlyURL> findByGroupId(long groupId,
426                    int start, int end,
427                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
428                    boolean retrieveFromCache);
429    
430            /**
431            * Returns the first layout friendly u r l in the ordered set where groupId = &#63;.
432            *
433            * @param groupId the group ID
434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
435            * @return the first matching layout friendly u r l
436            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
437            */
438            public LayoutFriendlyURL findByGroupId_First(long groupId,
439                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
440                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
441    
442            /**
443            * Returns the first layout friendly u r l in the ordered set where groupId = &#63;.
444            *
445            * @param groupId the group ID
446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
447            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
448            */
449            public LayoutFriendlyURL fetchByGroupId_First(long groupId,
450                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
451    
452            /**
453            * Returns the last layout friendly u r l in the ordered set where groupId = &#63;.
454            *
455            * @param groupId the group ID
456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
457            * @return the last matching layout friendly u r l
458            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
459            */
460            public LayoutFriendlyURL findByGroupId_Last(long groupId,
461                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
462                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
463    
464            /**
465            * Returns the last layout friendly u r l in the ordered set where groupId = &#63;.
466            *
467            * @param groupId the group ID
468            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
469            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
470            */
471            public LayoutFriendlyURL fetchByGroupId_Last(long groupId,
472                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
473    
474            /**
475            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = &#63;.
476            *
477            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
478            * @param groupId the group ID
479            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
480            * @return the previous, current, and next layout friendly u r l
481            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
482            */
483            public LayoutFriendlyURL[] findByGroupId_PrevAndNext(
484                    long layoutFriendlyURLId, long groupId,
485                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
486                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
487    
488            /**
489            * Removes all the layout friendly u r ls where groupId = &#63; from the database.
490            *
491            * @param groupId the group ID
492            */
493            public void removeByGroupId(long groupId);
494    
495            /**
496            * Returns the number of layout friendly u r ls where groupId = &#63;.
497            *
498            * @param groupId the group ID
499            * @return the number of matching layout friendly u r ls
500            */
501            public int countByGroupId(long groupId);
502    
503            /**
504            * Returns all the layout friendly u r ls where companyId = &#63;.
505            *
506            * @param companyId the company ID
507            * @return the matching layout friendly u r ls
508            */
509            public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId);
510    
511            /**
512            * Returns a range of all the layout friendly u r ls where companyId = &#63;.
513            *
514            * <p>
515            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutFriendlyURLModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
516            * </p>
517            *
518            * @param companyId the company ID
519            * @param start the lower bound of the range of layout friendly u r ls
520            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
521            * @return the range of matching layout friendly u r ls
522            */
523            public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId,
524                    int start, int end);
525    
526            /**
527            * Returns an ordered range of all the layout friendly u r ls where companyId = &#63;.
528            *
529            * <p>
530            * 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 LayoutFriendlyURLModelImpl}. 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.
531            * </p>
532            *
533            * @param companyId the company ID
534            * @param start the lower bound of the range of layout friendly u r ls
535            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
536            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
537            * @return the ordered range of matching layout friendly u r ls
538            */
539            public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId,
540                    int start, int end,
541                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
542    
543            /**
544            * Returns an ordered range of all the layout friendly u r ls where companyId = &#63;.
545            *
546            * <p>
547            * 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 LayoutFriendlyURLModelImpl}. 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.
548            * </p>
549            *
550            * @param companyId the company ID
551            * @param start the lower bound of the range of layout friendly u r ls
552            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
553            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
554            * @param retrieveFromCache whether to retrieve from the finder cache
555            * @return the ordered range of matching layout friendly u r ls
556            */
557            public java.util.List<LayoutFriendlyURL> findByCompanyId(long companyId,
558                    int start, int end,
559                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
560                    boolean retrieveFromCache);
561    
562            /**
563            * Returns the first layout friendly u r l in the ordered set where companyId = &#63;.
564            *
565            * @param companyId the company ID
566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
567            * @return the first matching layout friendly u r l
568            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
569            */
570            public LayoutFriendlyURL findByCompanyId_First(long companyId,
571                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
572                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
573    
574            /**
575            * Returns the first layout friendly u r l in the ordered set where companyId = &#63;.
576            *
577            * @param companyId the company ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
580            */
581            public LayoutFriendlyURL fetchByCompanyId_First(long companyId,
582                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
583    
584            /**
585            * Returns the last layout friendly u r l in the ordered set where companyId = &#63;.
586            *
587            * @param companyId the company ID
588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
589            * @return the last matching layout friendly u r l
590            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
591            */
592            public LayoutFriendlyURL findByCompanyId_Last(long companyId,
593                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
594                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
595    
596            /**
597            * Returns the last layout friendly u r l in the ordered set where companyId = &#63;.
598            *
599            * @param companyId the company ID
600            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
601            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
602            */
603            public LayoutFriendlyURL fetchByCompanyId_Last(long companyId,
604                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
605    
606            /**
607            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where companyId = &#63;.
608            *
609            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
610            * @param companyId the company ID
611            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
612            * @return the previous, current, and next layout friendly u r l
613            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
614            */
615            public LayoutFriendlyURL[] findByCompanyId_PrevAndNext(
616                    long layoutFriendlyURLId, long companyId,
617                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
618                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
619    
620            /**
621            * Removes all the layout friendly u r ls where companyId = &#63; from the database.
622            *
623            * @param companyId the company ID
624            */
625            public void removeByCompanyId(long companyId);
626    
627            /**
628            * Returns the number of layout friendly u r ls where companyId = &#63;.
629            *
630            * @param companyId the company ID
631            * @return the number of matching layout friendly u r ls
632            */
633            public int countByCompanyId(long companyId);
634    
635            /**
636            * Returns all the layout friendly u r ls where plid = &#63;.
637            *
638            * @param plid the plid
639            * @return the matching layout friendly u r ls
640            */
641            public java.util.List<LayoutFriendlyURL> findByPlid(long plid);
642    
643            /**
644            * Returns a range of all the layout friendly u r ls where plid = &#63;.
645            *
646            * <p>
647            * 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 LayoutFriendlyURLModelImpl}. 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.
648            * </p>
649            *
650            * @param plid the plid
651            * @param start the lower bound of the range of layout friendly u r ls
652            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
653            * @return the range of matching layout friendly u r ls
654            */
655            public java.util.List<LayoutFriendlyURL> findByPlid(long plid, int start,
656                    int end);
657    
658            /**
659            * Returns an ordered range of all the layout friendly u r ls where plid = &#63;.
660            *
661            * <p>
662            * 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 LayoutFriendlyURLModelImpl}. 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.
663            * </p>
664            *
665            * @param plid the plid
666            * @param start the lower bound of the range of layout friendly u r ls
667            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
668            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
669            * @return the ordered range of matching layout friendly u r ls
670            */
671            public java.util.List<LayoutFriendlyURL> findByPlid(long plid, int start,
672                    int end,
673                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
674    
675            /**
676            * Returns an ordered range of all the layout friendly u r ls where plid = &#63;.
677            *
678            * <p>
679            * 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 LayoutFriendlyURLModelImpl}. 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.
680            * </p>
681            *
682            * @param plid the plid
683            * @param start the lower bound of the range of layout friendly u r ls
684            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
685            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
686            * @param retrieveFromCache whether to retrieve from the finder cache
687            * @return the ordered range of matching layout friendly u r ls
688            */
689            public java.util.List<LayoutFriendlyURL> findByPlid(long plid, int start,
690                    int end,
691                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
692                    boolean retrieveFromCache);
693    
694            /**
695            * Returns the first layout friendly u r l in the ordered set where plid = &#63;.
696            *
697            * @param plid the plid
698            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
699            * @return the first matching layout friendly u r l
700            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
701            */
702            public LayoutFriendlyURL findByPlid_First(long plid,
703                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
704                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
705    
706            /**
707            * Returns the first layout friendly u r l in the ordered set where plid = &#63;.
708            *
709            * @param plid the plid
710            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
711            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
712            */
713            public LayoutFriendlyURL fetchByPlid_First(long plid,
714                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
715    
716            /**
717            * Returns the last layout friendly u r l in the ordered set where plid = &#63;.
718            *
719            * @param plid the plid
720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
721            * @return the last matching layout friendly u r l
722            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
723            */
724            public LayoutFriendlyURL findByPlid_Last(long plid,
725                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
726                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
727    
728            /**
729            * Returns the last layout friendly u r l in the ordered set where plid = &#63;.
730            *
731            * @param plid the plid
732            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
733            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
734            */
735            public LayoutFriendlyURL fetchByPlid_Last(long plid,
736                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
737    
738            /**
739            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = &#63;.
740            *
741            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
742            * @param plid the plid
743            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
744            * @return the previous, current, and next layout friendly u r l
745            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
746            */
747            public LayoutFriendlyURL[] findByPlid_PrevAndNext(
748                    long layoutFriendlyURLId, long plid,
749                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
750                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
751    
752            /**
753            * Removes all the layout friendly u r ls where plid = &#63; from the database.
754            *
755            * @param plid the plid
756            */
757            public void removeByPlid(long plid);
758    
759            /**
760            * Returns the number of layout friendly u r ls where plid = &#63;.
761            *
762            * @param plid the plid
763            * @return the number of matching layout friendly u r ls
764            */
765            public int countByPlid(long plid);
766    
767            /**
768            * Returns all the layout friendly u r ls where plid = &#63; and friendlyURL = &#63;.
769            *
770            * @param plid the plid
771            * @param friendlyURL the friendly u r l
772            * @return the matching layout friendly u r ls
773            */
774            public java.util.List<LayoutFriendlyURL> findByP_F(long plid,
775                    java.lang.String friendlyURL);
776    
777            /**
778            * Returns a range of all the layout friendly u r ls where plid = &#63; and friendlyURL = &#63;.
779            *
780            * <p>
781            * 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 LayoutFriendlyURLModelImpl}. 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.
782            * </p>
783            *
784            * @param plid the plid
785            * @param friendlyURL the friendly u r l
786            * @param start the lower bound of the range of layout friendly u r ls
787            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
788            * @return the range of matching layout friendly u r ls
789            */
790            public java.util.List<LayoutFriendlyURL> findByP_F(long plid,
791                    java.lang.String friendlyURL, int start, int end);
792    
793            /**
794            * Returns an ordered range of all the layout friendly u r ls where plid = &#63; and friendlyURL = &#63;.
795            *
796            * <p>
797            * 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 LayoutFriendlyURLModelImpl}. 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.
798            * </p>
799            *
800            * @param plid the plid
801            * @param friendlyURL the friendly u r l
802            * @param start the lower bound of the range of layout friendly u r ls
803            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
804            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
805            * @return the ordered range of matching layout friendly u r ls
806            */
807            public java.util.List<LayoutFriendlyURL> findByP_F(long plid,
808                    java.lang.String friendlyURL, int start, int end,
809                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
810    
811            /**
812            * Returns an ordered range of all the layout friendly u r ls where plid = &#63; and friendlyURL = &#63;.
813            *
814            * <p>
815            * 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 LayoutFriendlyURLModelImpl}. 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.
816            * </p>
817            *
818            * @param plid the plid
819            * @param friendlyURL the friendly u r l
820            * @param start the lower bound of the range of layout friendly u r ls
821            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
822            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
823            * @param retrieveFromCache whether to retrieve from the finder cache
824            * @return the ordered range of matching layout friendly u r ls
825            */
826            public java.util.List<LayoutFriendlyURL> findByP_F(long plid,
827                    java.lang.String friendlyURL, int start, int end,
828                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
829                    boolean retrieveFromCache);
830    
831            /**
832            * Returns the first layout friendly u r l in the ordered set where plid = &#63; and friendlyURL = &#63;.
833            *
834            * @param plid the plid
835            * @param friendlyURL the friendly u r l
836            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
837            * @return the first matching layout friendly u r l
838            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
839            */
840            public LayoutFriendlyURL findByP_F_First(long plid,
841                    java.lang.String friendlyURL,
842                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
843                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
844    
845            /**
846            * Returns the first layout friendly u r l in the ordered set where plid = &#63; and friendlyURL = &#63;.
847            *
848            * @param plid the plid
849            * @param friendlyURL the friendly u r l
850            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
851            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
852            */
853            public LayoutFriendlyURL fetchByP_F_First(long plid,
854                    java.lang.String friendlyURL,
855                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
856    
857            /**
858            * Returns the last layout friendly u r l in the ordered set where plid = &#63; and friendlyURL = &#63;.
859            *
860            * @param plid the plid
861            * @param friendlyURL the friendly u r l
862            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
863            * @return the last matching layout friendly u r l
864            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
865            */
866            public LayoutFriendlyURL findByP_F_Last(long plid,
867                    java.lang.String friendlyURL,
868                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
869                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
870    
871            /**
872            * Returns the last layout friendly u r l in the ordered set where plid = &#63; and friendlyURL = &#63;.
873            *
874            * @param plid the plid
875            * @param friendlyURL the friendly u r l
876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
877            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
878            */
879            public LayoutFriendlyURL fetchByP_F_Last(long plid,
880                    java.lang.String friendlyURL,
881                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
882    
883            /**
884            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = &#63; and friendlyURL = &#63;.
885            *
886            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
887            * @param plid the plid
888            * @param friendlyURL the friendly u r l
889            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
890            * @return the previous, current, and next layout friendly u r l
891            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
892            */
893            public LayoutFriendlyURL[] findByP_F_PrevAndNext(long layoutFriendlyURLId,
894                    long plid, java.lang.String friendlyURL,
895                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
896                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
897    
898            /**
899            * Removes all the layout friendly u r ls where plid = &#63; and friendlyURL = &#63; from the database.
900            *
901            * @param plid the plid
902            * @param friendlyURL the friendly u r l
903            */
904            public void removeByP_F(long plid, java.lang.String friendlyURL);
905    
906            /**
907            * Returns the number of layout friendly u r ls where plid = &#63; and friendlyURL = &#63;.
908            *
909            * @param plid the plid
910            * @param friendlyURL the friendly u r l
911            * @return the number of matching layout friendly u r ls
912            */
913            public int countByP_F(long plid, java.lang.String friendlyURL);
914    
915            /**
916            * Returns the layout friendly u r l where plid = &#63; and languageId = &#63; or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found.
917            *
918            * @param plid the plid
919            * @param languageId the language ID
920            * @return the matching layout friendly u r l
921            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
922            */
923            public LayoutFriendlyURL findByP_L(long plid, java.lang.String languageId)
924                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
925    
926            /**
927            * Returns the layout friendly u r l where plid = &#63; and languageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
928            *
929            * @param plid the plid
930            * @param languageId the language ID
931            * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
932            */
933            public LayoutFriendlyURL fetchByP_L(long plid, java.lang.String languageId);
934    
935            /**
936            * Returns the layout friendly u r l where plid = &#63; and languageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
937            *
938            * @param plid the plid
939            * @param languageId the language ID
940            * @param retrieveFromCache whether to retrieve from the finder cache
941            * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
942            */
943            public LayoutFriendlyURL fetchByP_L(long plid, java.lang.String languageId,
944                    boolean retrieveFromCache);
945    
946            /**
947            * Removes the layout friendly u r l where plid = &#63; and languageId = &#63; from the database.
948            *
949            * @param plid the plid
950            * @param languageId the language ID
951            * @return the layout friendly u r l that was removed
952            */
953            public LayoutFriendlyURL removeByP_L(long plid, java.lang.String languageId)
954                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
955    
956            /**
957            * Returns the number of layout friendly u r ls where plid = &#63; and languageId = &#63;.
958            *
959            * @param plid the plid
960            * @param languageId the language ID
961            * @return the number of matching layout friendly u r ls
962            */
963            public int countByP_L(long plid, java.lang.String languageId);
964    
965            /**
966            * Returns all the layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
967            *
968            * @param groupId the group ID
969            * @param privateLayout the private layout
970            * @param friendlyURL the friendly u r l
971            * @return the matching layout friendly u r ls
972            */
973            public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId,
974                    boolean privateLayout, java.lang.String friendlyURL);
975    
976            /**
977            * Returns a range of all the layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
978            *
979            * <p>
980            * 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 LayoutFriendlyURLModelImpl}. 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.
981            * </p>
982            *
983            * @param groupId the group ID
984            * @param privateLayout the private layout
985            * @param friendlyURL the friendly u r l
986            * @param start the lower bound of the range of layout friendly u r ls
987            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
988            * @return the range of matching layout friendly u r ls
989            */
990            public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId,
991                    boolean privateLayout, java.lang.String friendlyURL, int start, int end);
992    
993            /**
994            * Returns an ordered range of all the layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
995            *
996            * <p>
997            * 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 LayoutFriendlyURLModelImpl}. 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.
998            * </p>
999            *
1000            * @param groupId the group ID
1001            * @param privateLayout the private layout
1002            * @param friendlyURL the friendly u r l
1003            * @param start the lower bound of the range of layout friendly u r ls
1004            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
1005            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1006            * @return the ordered range of matching layout friendly u r ls
1007            */
1008            public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId,
1009                    boolean privateLayout, java.lang.String friendlyURL, int start,
1010                    int end,
1011                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
1012    
1013            /**
1014            * Returns an ordered range of all the layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1015            *
1016            * <p>
1017            * 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 LayoutFriendlyURLModelImpl}. 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.
1018            * </p>
1019            *
1020            * @param groupId the group ID
1021            * @param privateLayout the private layout
1022            * @param friendlyURL the friendly u r l
1023            * @param start the lower bound of the range of layout friendly u r ls
1024            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
1025            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1026            * @param retrieveFromCache whether to retrieve from the finder cache
1027            * @return the ordered range of matching layout friendly u r ls
1028            */
1029            public java.util.List<LayoutFriendlyURL> findByG_P_F(long groupId,
1030                    boolean privateLayout, java.lang.String friendlyURL, int start,
1031                    int end,
1032                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
1033                    boolean retrieveFromCache);
1034    
1035            /**
1036            * Returns the first layout friendly u r l in the ordered set where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1037            *
1038            * @param groupId the group ID
1039            * @param privateLayout the private layout
1040            * @param friendlyURL the friendly u r l
1041            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1042            * @return the first matching layout friendly u r l
1043            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
1044            */
1045            public LayoutFriendlyURL findByG_P_F_First(long groupId,
1046                    boolean privateLayout, java.lang.String friendlyURL,
1047                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
1048                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1049    
1050            /**
1051            * Returns the first layout friendly u r l in the ordered set where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1052            *
1053            * @param groupId the group ID
1054            * @param privateLayout the private layout
1055            * @param friendlyURL the friendly u r l
1056            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1057            * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
1058            */
1059            public LayoutFriendlyURL fetchByG_P_F_First(long groupId,
1060                    boolean privateLayout, java.lang.String friendlyURL,
1061                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
1062    
1063            /**
1064            * Returns the last layout friendly u r l in the ordered set where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1065            *
1066            * @param groupId the group ID
1067            * @param privateLayout the private layout
1068            * @param friendlyURL the friendly u r l
1069            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1070            * @return the last matching layout friendly u r l
1071            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
1072            */
1073            public LayoutFriendlyURL findByG_P_F_Last(long groupId,
1074                    boolean privateLayout, java.lang.String friendlyURL,
1075                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
1076                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1077    
1078            /**
1079            * Returns the last layout friendly u r l in the ordered set where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1080            *
1081            * @param groupId the group ID
1082            * @param privateLayout the private layout
1083            * @param friendlyURL the friendly u r l
1084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1085            * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
1086            */
1087            public LayoutFriendlyURL fetchByG_P_F_Last(long groupId,
1088                    boolean privateLayout, java.lang.String friendlyURL,
1089                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
1090    
1091            /**
1092            * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1093            *
1094            * @param layoutFriendlyURLId the primary key of the current layout friendly u r l
1095            * @param groupId the group ID
1096            * @param privateLayout the private layout
1097            * @param friendlyURL the friendly u r l
1098            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1099            * @return the previous, current, and next layout friendly u r l
1100            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
1101            */
1102            public LayoutFriendlyURL[] findByG_P_F_PrevAndNext(
1103                    long layoutFriendlyURLId, long groupId, boolean privateLayout,
1104                    java.lang.String friendlyURL,
1105                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator)
1106                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1107    
1108            /**
1109            * Removes all the layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; from the database.
1110            *
1111            * @param groupId the group ID
1112            * @param privateLayout the private layout
1113            * @param friendlyURL the friendly u r l
1114            */
1115            public void removeByG_P_F(long groupId, boolean privateLayout,
1116                    java.lang.String friendlyURL);
1117    
1118            /**
1119            * Returns the number of layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63;.
1120            *
1121            * @param groupId the group ID
1122            * @param privateLayout the private layout
1123            * @param friendlyURL the friendly u r l
1124            * @return the number of matching layout friendly u r ls
1125            */
1126            public int countByG_P_F(long groupId, boolean privateLayout,
1127                    java.lang.String friendlyURL);
1128    
1129            /**
1130            * Returns the layout friendly u r l where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; and languageId = &#63; or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found.
1131            *
1132            * @param groupId the group ID
1133            * @param privateLayout the private layout
1134            * @param friendlyURL the friendly u r l
1135            * @param languageId the language ID
1136            * @return the matching layout friendly u r l
1137            * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found
1138            */
1139            public LayoutFriendlyURL findByG_P_F_L(long groupId, boolean privateLayout,
1140                    java.lang.String friendlyURL, java.lang.String languageId)
1141                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1142    
1143            /**
1144            * Returns the layout friendly u r l where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; and languageId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1145            *
1146            * @param groupId the group ID
1147            * @param privateLayout the private layout
1148            * @param friendlyURL the friendly u r l
1149            * @param languageId the language ID
1150            * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
1151            */
1152            public LayoutFriendlyURL fetchByG_P_F_L(long groupId,
1153                    boolean privateLayout, java.lang.String friendlyURL,
1154                    java.lang.String languageId);
1155    
1156            /**
1157            * Returns the layout friendly u r l where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; and languageId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1158            *
1159            * @param groupId the group ID
1160            * @param privateLayout the private layout
1161            * @param friendlyURL the friendly u r l
1162            * @param languageId the language ID
1163            * @param retrieveFromCache whether to retrieve from the finder cache
1164            * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found
1165            */
1166            public LayoutFriendlyURL fetchByG_P_F_L(long groupId,
1167                    boolean privateLayout, java.lang.String friendlyURL,
1168                    java.lang.String languageId, boolean retrieveFromCache);
1169    
1170            /**
1171            * Removes the layout friendly u r l where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; and languageId = &#63; from the database.
1172            *
1173            * @param groupId the group ID
1174            * @param privateLayout the private layout
1175            * @param friendlyURL the friendly u r l
1176            * @param languageId the language ID
1177            * @return the layout friendly u r l that was removed
1178            */
1179            public LayoutFriendlyURL removeByG_P_F_L(long groupId,
1180                    boolean privateLayout, java.lang.String friendlyURL,
1181                    java.lang.String languageId)
1182                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1183    
1184            /**
1185            * Returns the number of layout friendly u r ls where groupId = &#63; and privateLayout = &#63; and friendlyURL = &#63; and languageId = &#63;.
1186            *
1187            * @param groupId the group ID
1188            * @param privateLayout the private layout
1189            * @param friendlyURL the friendly u r l
1190            * @param languageId the language ID
1191            * @return the number of matching layout friendly u r ls
1192            */
1193            public int countByG_P_F_L(long groupId, boolean privateLayout,
1194                    java.lang.String friendlyURL, java.lang.String languageId);
1195    
1196            /**
1197            * Caches the layout friendly u r l in the entity cache if it is enabled.
1198            *
1199            * @param layoutFriendlyURL the layout friendly u r l
1200            */
1201            public void cacheResult(LayoutFriendlyURL layoutFriendlyURL);
1202    
1203            /**
1204            * Caches the layout friendly u r ls in the entity cache if it is enabled.
1205            *
1206            * @param layoutFriendlyURLs the layout friendly u r ls
1207            */
1208            public void cacheResult(
1209                    java.util.List<LayoutFriendlyURL> layoutFriendlyURLs);
1210    
1211            /**
1212            * Creates a new layout friendly u r l with the primary key. Does not add the layout friendly u r l to the database.
1213            *
1214            * @param layoutFriendlyURLId the primary key for the new layout friendly u r l
1215            * @return the new layout friendly u r l
1216            */
1217            public LayoutFriendlyURL create(long layoutFriendlyURLId);
1218    
1219            /**
1220            * Removes the layout friendly u r l with the primary key from the database. Also notifies the appropriate model listeners.
1221            *
1222            * @param layoutFriendlyURLId the primary key of the layout friendly u r l
1223            * @return the layout friendly u r l that was removed
1224            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
1225            */
1226            public LayoutFriendlyURL remove(long layoutFriendlyURLId)
1227                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1228    
1229            public LayoutFriendlyURL updateImpl(LayoutFriendlyURL layoutFriendlyURL);
1230    
1231            /**
1232            * Returns the layout friendly u r l with the primary key or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found.
1233            *
1234            * @param layoutFriendlyURLId the primary key of the layout friendly u r l
1235            * @return the layout friendly u r l
1236            * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found
1237            */
1238            public LayoutFriendlyURL findByPrimaryKey(long layoutFriendlyURLId)
1239                    throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException;
1240    
1241            /**
1242            * Returns the layout friendly u r l with the primary key or returns <code>null</code> if it could not be found.
1243            *
1244            * @param layoutFriendlyURLId the primary key of the layout friendly u r l
1245            * @return the layout friendly u r l, or <code>null</code> if a layout friendly u r l with the primary key could not be found
1246            */
1247            public LayoutFriendlyURL fetchByPrimaryKey(long layoutFriendlyURLId);
1248    
1249            @Override
1250            public java.util.Map<java.io.Serializable, LayoutFriendlyURL> fetchByPrimaryKeys(
1251                    java.util.Set<java.io.Serializable> primaryKeys);
1252    
1253            /**
1254            * Returns all the layout friendly u r ls.
1255            *
1256            * @return the layout friendly u r ls
1257            */
1258            public java.util.List<LayoutFriendlyURL> findAll();
1259    
1260            /**
1261            * Returns a range of all the layout friendly u r ls.
1262            *
1263            * <p>
1264            * 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 LayoutFriendlyURLModelImpl}. 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.
1265            * </p>
1266            *
1267            * @param start the lower bound of the range of layout friendly u r ls
1268            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
1269            * @return the range of layout friendly u r ls
1270            */
1271            public java.util.List<LayoutFriendlyURL> findAll(int start, int end);
1272    
1273            /**
1274            * Returns an ordered range of all the layout friendly u r ls.
1275            *
1276            * <p>
1277            * 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 LayoutFriendlyURLModelImpl}. 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.
1278            * </p>
1279            *
1280            * @param start the lower bound of the range of layout friendly u r ls
1281            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
1282            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1283            * @return the ordered range of layout friendly u r ls
1284            */
1285            public java.util.List<LayoutFriendlyURL> findAll(int start, int end,
1286                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator);
1287    
1288            /**
1289            * Returns an ordered range of all the layout friendly u r ls.
1290            *
1291            * <p>
1292            * 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 LayoutFriendlyURLModelImpl}. 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.
1293            * </p>
1294            *
1295            * @param start the lower bound of the range of layout friendly u r ls
1296            * @param end the upper bound of the range of layout friendly u r ls (not inclusive)
1297            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1298            * @param retrieveFromCache whether to retrieve from the finder cache
1299            * @return the ordered range of layout friendly u r ls
1300            */
1301            public java.util.List<LayoutFriendlyURL> findAll(int start, int end,
1302                    com.liferay.portal.kernel.util.OrderByComparator<LayoutFriendlyURL> orderByComparator,
1303                    boolean retrieveFromCache);
1304    
1305            /**
1306            * Removes all the layout friendly u r ls from the database.
1307            */
1308            public void removeAll();
1309    
1310            /**
1311            * Returns the number of layout friendly u r ls.
1312            *
1313            * @return the number of layout friendly u r ls
1314            */
1315            public int countAll();
1316    
1317            @Override
1318            public java.util.Set<java.lang.String> getBadColumnNames();
1319    }