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