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