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