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.portlet.softwarecatalog.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.service.ServiceContext; 024 025 import com.liferay.portlet.softwarecatalog.model.SCProductScreenshot; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the s c product screenshot service. This utility wraps {@link com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductScreenshotPersistenceImpl} 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see SCProductScreenshotPersistence 038 * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductScreenshotPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class SCProductScreenshotUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(SCProductScreenshot scProductScreenshot) { 060 getPersistence().clearCache(scProductScreenshot); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<SCProductScreenshot> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<SCProductScreenshot> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<SCProductScreenshot> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<SCProductScreenshot> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static SCProductScreenshot update( 101 SCProductScreenshot scProductScreenshot) { 102 return getPersistence().update(scProductScreenshot); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static SCProductScreenshot update( 109 SCProductScreenshot scProductScreenshot, ServiceContext serviceContext) { 110 return getPersistence().update(scProductScreenshot, serviceContext); 111 } 112 113 /** 114 * Returns all the s c product screenshots where productEntryId = ?. 115 * 116 * @param productEntryId the product entry ID 117 * @return the matching s c product screenshots 118 */ 119 public static List<SCProductScreenshot> findByProductEntryId( 120 long productEntryId) { 121 return getPersistence().findByProductEntryId(productEntryId); 122 } 123 124 /** 125 * Returns a range of all the s c product screenshots where productEntryId = ?. 126 * 127 * <p> 128 * 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 SCProductScreenshotModelImpl}. 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. 129 * </p> 130 * 131 * @param productEntryId the product entry ID 132 * @param start the lower bound of the range of s c product screenshots 133 * @param end the upper bound of the range of s c product screenshots (not inclusive) 134 * @return the range of matching s c product screenshots 135 */ 136 public static List<SCProductScreenshot> findByProductEntryId( 137 long productEntryId, int start, int end) { 138 return getPersistence().findByProductEntryId(productEntryId, start, end); 139 } 140 141 /** 142 * Returns an ordered range of all the s c product screenshots where productEntryId = ?. 143 * 144 * <p> 145 * 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 SCProductScreenshotModelImpl}. 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. 146 * </p> 147 * 148 * @param productEntryId the product entry ID 149 * @param start the lower bound of the range of s c product screenshots 150 * @param end the upper bound of the range of s c product screenshots (not inclusive) 151 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 152 * @return the ordered range of matching s c product screenshots 153 */ 154 public static List<SCProductScreenshot> findByProductEntryId( 155 long productEntryId, int start, int end, 156 OrderByComparator<SCProductScreenshot> orderByComparator) { 157 return getPersistence() 158 .findByProductEntryId(productEntryId, start, end, 159 orderByComparator); 160 } 161 162 /** 163 * Returns an ordered range of all the s c product screenshots where productEntryId = ?. 164 * 165 * <p> 166 * 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 SCProductScreenshotModelImpl}. 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. 167 * </p> 168 * 169 * @param productEntryId the product entry ID 170 * @param start the lower bound of the range of s c product screenshots 171 * @param end the upper bound of the range of s c product screenshots (not inclusive) 172 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 173 * @param retrieveFromCache whether to retrieve from the finder cache 174 * @return the ordered range of matching s c product screenshots 175 */ 176 public static List<SCProductScreenshot> findByProductEntryId( 177 long productEntryId, int start, int end, 178 OrderByComparator<SCProductScreenshot> orderByComparator, 179 boolean retrieveFromCache) { 180 return getPersistence() 181 .findByProductEntryId(productEntryId, start, end, 182 orderByComparator, retrieveFromCache); 183 } 184 185 /** 186 * Returns the first s c product screenshot in the ordered set where productEntryId = ?. 187 * 188 * @param productEntryId the product entry ID 189 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 190 * @return the first matching s c product screenshot 191 * @throws NoSuchProductScreenshotException if a matching s c product screenshot could not be found 192 */ 193 public static SCProductScreenshot findByProductEntryId_First( 194 long productEntryId, 195 OrderByComparator<SCProductScreenshot> orderByComparator) 196 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 197 return getPersistence() 198 .findByProductEntryId_First(productEntryId, orderByComparator); 199 } 200 201 /** 202 * Returns the first s c product screenshot in the ordered set where productEntryId = ?. 203 * 204 * @param productEntryId the product entry ID 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the first matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 207 */ 208 public static SCProductScreenshot fetchByProductEntryId_First( 209 long productEntryId, 210 OrderByComparator<SCProductScreenshot> orderByComparator) { 211 return getPersistence() 212 .fetchByProductEntryId_First(productEntryId, 213 orderByComparator); 214 } 215 216 /** 217 * Returns the last s c product screenshot in the ordered set where productEntryId = ?. 218 * 219 * @param productEntryId the product entry ID 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching s c product screenshot 222 * @throws NoSuchProductScreenshotException if a matching s c product screenshot could not be found 223 */ 224 public static SCProductScreenshot findByProductEntryId_Last( 225 long productEntryId, 226 OrderByComparator<SCProductScreenshot> orderByComparator) 227 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 228 return getPersistence() 229 .findByProductEntryId_Last(productEntryId, orderByComparator); 230 } 231 232 /** 233 * Returns the last s c product screenshot in the ordered set where productEntryId = ?. 234 * 235 * @param productEntryId the product entry ID 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the last matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 238 */ 239 public static SCProductScreenshot fetchByProductEntryId_Last( 240 long productEntryId, 241 OrderByComparator<SCProductScreenshot> orderByComparator) { 242 return getPersistence() 243 .fetchByProductEntryId_Last(productEntryId, orderByComparator); 244 } 245 246 /** 247 * Returns the s c product screenshots before and after the current s c product screenshot in the ordered set where productEntryId = ?. 248 * 249 * @param productScreenshotId the primary key of the current s c product screenshot 250 * @param productEntryId the product entry ID 251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 252 * @return the previous, current, and next s c product screenshot 253 * @throws NoSuchProductScreenshotException if a s c product screenshot with the primary key could not be found 254 */ 255 public static SCProductScreenshot[] findByProductEntryId_PrevAndNext( 256 long productScreenshotId, long productEntryId, 257 OrderByComparator<SCProductScreenshot> orderByComparator) 258 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 259 return getPersistence() 260 .findByProductEntryId_PrevAndNext(productScreenshotId, 261 productEntryId, orderByComparator); 262 } 263 264 /** 265 * Removes all the s c product screenshots where productEntryId = ? from the database. 266 * 267 * @param productEntryId the product entry ID 268 */ 269 public static void removeByProductEntryId(long productEntryId) { 270 getPersistence().removeByProductEntryId(productEntryId); 271 } 272 273 /** 274 * Returns the number of s c product screenshots where productEntryId = ?. 275 * 276 * @param productEntryId the product entry ID 277 * @return the number of matching s c product screenshots 278 */ 279 public static int countByProductEntryId(long productEntryId) { 280 return getPersistence().countByProductEntryId(productEntryId); 281 } 282 283 /** 284 * Returns the s c product screenshot where thumbnailId = ? or throws a {@link NoSuchProductScreenshotException} if it could not be found. 285 * 286 * @param thumbnailId the thumbnail ID 287 * @return the matching s c product screenshot 288 * @throws NoSuchProductScreenshotException if a matching s c product screenshot could not be found 289 */ 290 public static SCProductScreenshot findByThumbnailId(long thumbnailId) 291 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 292 return getPersistence().findByThumbnailId(thumbnailId); 293 } 294 295 /** 296 * Returns the s c product screenshot where thumbnailId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 297 * 298 * @param thumbnailId the thumbnail ID 299 * @return the matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 300 */ 301 public static SCProductScreenshot fetchByThumbnailId(long thumbnailId) { 302 return getPersistence().fetchByThumbnailId(thumbnailId); 303 } 304 305 /** 306 * Returns the s c product screenshot where thumbnailId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 307 * 308 * @param thumbnailId the thumbnail ID 309 * @param retrieveFromCache whether to retrieve from the finder cache 310 * @return the matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 311 */ 312 public static SCProductScreenshot fetchByThumbnailId(long thumbnailId, 313 boolean retrieveFromCache) { 314 return getPersistence() 315 .fetchByThumbnailId(thumbnailId, retrieveFromCache); 316 } 317 318 /** 319 * Removes the s c product screenshot where thumbnailId = ? from the database. 320 * 321 * @param thumbnailId the thumbnail ID 322 * @return the s c product screenshot that was removed 323 */ 324 public static SCProductScreenshot removeByThumbnailId(long thumbnailId) 325 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 326 return getPersistence().removeByThumbnailId(thumbnailId); 327 } 328 329 /** 330 * Returns the number of s c product screenshots where thumbnailId = ?. 331 * 332 * @param thumbnailId the thumbnail ID 333 * @return the number of matching s c product screenshots 334 */ 335 public static int countByThumbnailId(long thumbnailId) { 336 return getPersistence().countByThumbnailId(thumbnailId); 337 } 338 339 /** 340 * Returns the s c product screenshot where fullImageId = ? or throws a {@link NoSuchProductScreenshotException} if it could not be found. 341 * 342 * @param fullImageId the full image ID 343 * @return the matching s c product screenshot 344 * @throws NoSuchProductScreenshotException if a matching s c product screenshot could not be found 345 */ 346 public static SCProductScreenshot findByFullImageId(long fullImageId) 347 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 348 return getPersistence().findByFullImageId(fullImageId); 349 } 350 351 /** 352 * Returns the s c product screenshot where fullImageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 353 * 354 * @param fullImageId the full image ID 355 * @return the matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 356 */ 357 public static SCProductScreenshot fetchByFullImageId(long fullImageId) { 358 return getPersistence().fetchByFullImageId(fullImageId); 359 } 360 361 /** 362 * Returns the s c product screenshot where fullImageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 363 * 364 * @param fullImageId the full image ID 365 * @param retrieveFromCache whether to retrieve from the finder cache 366 * @return the matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 367 */ 368 public static SCProductScreenshot fetchByFullImageId(long fullImageId, 369 boolean retrieveFromCache) { 370 return getPersistence() 371 .fetchByFullImageId(fullImageId, retrieveFromCache); 372 } 373 374 /** 375 * Removes the s c product screenshot where fullImageId = ? from the database. 376 * 377 * @param fullImageId the full image ID 378 * @return the s c product screenshot that was removed 379 */ 380 public static SCProductScreenshot removeByFullImageId(long fullImageId) 381 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 382 return getPersistence().removeByFullImageId(fullImageId); 383 } 384 385 /** 386 * Returns the number of s c product screenshots where fullImageId = ?. 387 * 388 * @param fullImageId the full image ID 389 * @return the number of matching s c product screenshots 390 */ 391 public static int countByFullImageId(long fullImageId) { 392 return getPersistence().countByFullImageId(fullImageId); 393 } 394 395 /** 396 * Returns the s c product screenshot where productEntryId = ? and priority = ? or throws a {@link NoSuchProductScreenshotException} if it could not be found. 397 * 398 * @param productEntryId the product entry ID 399 * @param priority the priority 400 * @return the matching s c product screenshot 401 * @throws NoSuchProductScreenshotException if a matching s c product screenshot could not be found 402 */ 403 public static SCProductScreenshot findByP_P(long productEntryId, 404 int priority) 405 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 406 return getPersistence().findByP_P(productEntryId, priority); 407 } 408 409 /** 410 * Returns the s c product screenshot where productEntryId = ? and priority = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 411 * 412 * @param productEntryId the product entry ID 413 * @param priority the priority 414 * @return the matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 415 */ 416 public static SCProductScreenshot fetchByP_P(long productEntryId, 417 int priority) { 418 return getPersistence().fetchByP_P(productEntryId, priority); 419 } 420 421 /** 422 * Returns the s c product screenshot where productEntryId = ? and priority = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 423 * 424 * @param productEntryId the product entry ID 425 * @param priority the priority 426 * @param retrieveFromCache whether to retrieve from the finder cache 427 * @return the matching s c product screenshot, or <code>null</code> if a matching s c product screenshot could not be found 428 */ 429 public static SCProductScreenshot fetchByP_P(long productEntryId, 430 int priority, boolean retrieveFromCache) { 431 return getPersistence() 432 .fetchByP_P(productEntryId, priority, retrieveFromCache); 433 } 434 435 /** 436 * Removes the s c product screenshot where productEntryId = ? and priority = ? from the database. 437 * 438 * @param productEntryId the product entry ID 439 * @param priority the priority 440 * @return the s c product screenshot that was removed 441 */ 442 public static SCProductScreenshot removeByP_P(long productEntryId, 443 int priority) 444 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 445 return getPersistence().removeByP_P(productEntryId, priority); 446 } 447 448 /** 449 * Returns the number of s c product screenshots where productEntryId = ? and priority = ?. 450 * 451 * @param productEntryId the product entry ID 452 * @param priority the priority 453 * @return the number of matching s c product screenshots 454 */ 455 public static int countByP_P(long productEntryId, int priority) { 456 return getPersistence().countByP_P(productEntryId, priority); 457 } 458 459 /** 460 * Caches the s c product screenshot in the entity cache if it is enabled. 461 * 462 * @param scProductScreenshot the s c product screenshot 463 */ 464 public static void cacheResult(SCProductScreenshot scProductScreenshot) { 465 getPersistence().cacheResult(scProductScreenshot); 466 } 467 468 /** 469 * Caches the s c product screenshots in the entity cache if it is enabled. 470 * 471 * @param scProductScreenshots the s c product screenshots 472 */ 473 public static void cacheResult( 474 List<SCProductScreenshot> scProductScreenshots) { 475 getPersistence().cacheResult(scProductScreenshots); 476 } 477 478 /** 479 * Creates a new s c product screenshot with the primary key. Does not add the s c product screenshot to the database. 480 * 481 * @param productScreenshotId the primary key for the new s c product screenshot 482 * @return the new s c product screenshot 483 */ 484 public static SCProductScreenshot create(long productScreenshotId) { 485 return getPersistence().create(productScreenshotId); 486 } 487 488 /** 489 * Removes the s c product screenshot with the primary key from the database. Also notifies the appropriate model listeners. 490 * 491 * @param productScreenshotId the primary key of the s c product screenshot 492 * @return the s c product screenshot that was removed 493 * @throws NoSuchProductScreenshotException if a s c product screenshot with the primary key could not be found 494 */ 495 public static SCProductScreenshot remove(long productScreenshotId) 496 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 497 return getPersistence().remove(productScreenshotId); 498 } 499 500 public static SCProductScreenshot updateImpl( 501 SCProductScreenshot scProductScreenshot) { 502 return getPersistence().updateImpl(scProductScreenshot); 503 } 504 505 /** 506 * Returns the s c product screenshot with the primary key or throws a {@link NoSuchProductScreenshotException} if it could not be found. 507 * 508 * @param productScreenshotId the primary key of the s c product screenshot 509 * @return the s c product screenshot 510 * @throws NoSuchProductScreenshotException if a s c product screenshot with the primary key could not be found 511 */ 512 public static SCProductScreenshot findByPrimaryKey(long productScreenshotId) 513 throws com.liferay.portlet.softwarecatalog.NoSuchProductScreenshotException { 514 return getPersistence().findByPrimaryKey(productScreenshotId); 515 } 516 517 /** 518 * Returns the s c product screenshot with the primary key or returns <code>null</code> if it could not be found. 519 * 520 * @param productScreenshotId the primary key of the s c product screenshot 521 * @return the s c product screenshot, or <code>null</code> if a s c product screenshot with the primary key could not be found 522 */ 523 public static SCProductScreenshot fetchByPrimaryKey( 524 long productScreenshotId) { 525 return getPersistence().fetchByPrimaryKey(productScreenshotId); 526 } 527 528 public static java.util.Map<java.io.Serializable, SCProductScreenshot> fetchByPrimaryKeys( 529 java.util.Set<java.io.Serializable> primaryKeys) { 530 return getPersistence().fetchByPrimaryKeys(primaryKeys); 531 } 532 533 /** 534 * Returns all the s c product screenshots. 535 * 536 * @return the s c product screenshots 537 */ 538 public static List<SCProductScreenshot> findAll() { 539 return getPersistence().findAll(); 540 } 541 542 /** 543 * Returns a range of all the s c product screenshots. 544 * 545 * <p> 546 * 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 SCProductScreenshotModelImpl}. 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. 547 * </p> 548 * 549 * @param start the lower bound of the range of s c product screenshots 550 * @param end the upper bound of the range of s c product screenshots (not inclusive) 551 * @return the range of s c product screenshots 552 */ 553 public static List<SCProductScreenshot> findAll(int start, int end) { 554 return getPersistence().findAll(start, end); 555 } 556 557 /** 558 * Returns an ordered range of all the s c product screenshots. 559 * 560 * <p> 561 * 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 SCProductScreenshotModelImpl}. 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. 562 * </p> 563 * 564 * @param start the lower bound of the range of s c product screenshots 565 * @param end the upper bound of the range of s c product screenshots (not inclusive) 566 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 567 * @return the ordered range of s c product screenshots 568 */ 569 public static List<SCProductScreenshot> findAll(int start, int end, 570 OrderByComparator<SCProductScreenshot> orderByComparator) { 571 return getPersistence().findAll(start, end, orderByComparator); 572 } 573 574 /** 575 * Returns an ordered range of all the s c product screenshots. 576 * 577 * <p> 578 * 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 SCProductScreenshotModelImpl}. 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. 579 * </p> 580 * 581 * @param start the lower bound of the range of s c product screenshots 582 * @param end the upper bound of the range of s c product screenshots (not inclusive) 583 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 584 * @param retrieveFromCache whether to retrieve from the finder cache 585 * @return the ordered range of s c product screenshots 586 */ 587 public static List<SCProductScreenshot> findAll(int start, int end, 588 OrderByComparator<SCProductScreenshot> orderByComparator, 589 boolean retrieveFromCache) { 590 return getPersistence() 591 .findAll(start, end, orderByComparator, retrieveFromCache); 592 } 593 594 /** 595 * Removes all the s c product screenshots from the database. 596 */ 597 public static void removeAll() { 598 getPersistence().removeAll(); 599 } 600 601 /** 602 * Returns the number of s c product screenshots. 603 * 604 * @return the number of s c product screenshots 605 */ 606 public static int countAll() { 607 return getPersistence().countAll(); 608 } 609 610 public static SCProductScreenshotPersistence getPersistence() { 611 if (_persistence == null) { 612 _persistence = (SCProductScreenshotPersistence)PortalBeanLocatorUtil.locate(SCProductScreenshotPersistence.class.getName()); 613 614 ReferenceRegistry.registerReference(SCProductScreenshotUtil.class, 615 "_persistence"); 616 } 617 618 return _persistence; 619 } 620 621 /** 622 * @deprecated As of 6.2.0 623 */ 624 @Deprecated 625 public void setPersistence(SCProductScreenshotPersistence persistence) { 626 } 627 628 private static SCProductScreenshotPersistence _persistence; 629 }