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