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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ? 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ?. 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 = ? and portletId = ? 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 = ? and portletId = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and plid = ? 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 = ? and ownerType = ? and plid = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ?. 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 = ? and ownerType = ? and portletId = ? 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 = ? and ownerType = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ?. 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 = ? and plid = ? and portletId = ? 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 = ? and plid = ? and portletId = ?. 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 = ? and ownerType = ? and plid = ? and portletId = ? 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 = ? and ownerType = ? and plid = ? and portletId = ? 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 = ? and ownerType = ? and plid = ? and portletId = ? 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 = ? and ownerType = ? and plid = ? and portletId = ? 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 = ? and ownerType = ? and plid = ? and portletId = ?. 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 }