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