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.SCProductVersion; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the s c product version service. This utility wraps {@link com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductVersionPersistenceImpl} 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 SCProductVersionPersistence 038 * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductVersionPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class SCProductVersionUtil { 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(SCProductVersion scProductVersion) { 060 getPersistence().clearCache(scProductVersion); 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<SCProductVersion> 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<SCProductVersion> 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<SCProductVersion> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<SCProductVersion> 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 SCProductVersion update(SCProductVersion scProductVersion) { 101 return getPersistence().update(scProductVersion); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static SCProductVersion update(SCProductVersion scProductVersion, 108 ServiceContext serviceContext) { 109 return getPersistence().update(scProductVersion, serviceContext); 110 } 111 112 /** 113 * Returns all the s c product versions where productEntryId = ?. 114 * 115 * @param productEntryId the product entry ID 116 * @return the matching s c product versions 117 */ 118 public static List<SCProductVersion> findByProductEntryId( 119 long productEntryId) { 120 return getPersistence().findByProductEntryId(productEntryId); 121 } 122 123 /** 124 * Returns a range of all the s c product versions where productEntryId = ?. 125 * 126 * <p> 127 * 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 SCProductVersionModelImpl}. 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. 128 * </p> 129 * 130 * @param productEntryId the product entry ID 131 * @param start the lower bound of the range of s c product versions 132 * @param end the upper bound of the range of s c product versions (not inclusive) 133 * @return the range of matching s c product versions 134 */ 135 public static List<SCProductVersion> findByProductEntryId( 136 long productEntryId, int start, int end) { 137 return getPersistence().findByProductEntryId(productEntryId, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the s c product versions where productEntryId = ?. 142 * 143 * <p> 144 * 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 SCProductVersionModelImpl}. 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. 145 * </p> 146 * 147 * @param productEntryId the product entry ID 148 * @param start the lower bound of the range of s c product versions 149 * @param end the upper bound of the range of s c product versions (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching s c product versions 152 */ 153 public static List<SCProductVersion> findByProductEntryId( 154 long productEntryId, int start, int end, 155 OrderByComparator<SCProductVersion> orderByComparator) { 156 return getPersistence() 157 .findByProductEntryId(productEntryId, start, end, 158 orderByComparator); 159 } 160 161 /** 162 * Returns an ordered range of all the s c product versions where productEntryId = ?. 163 * 164 * <p> 165 * 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 SCProductVersionModelImpl}. 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. 166 * </p> 167 * 168 * @param productEntryId the product entry ID 169 * @param start the lower bound of the range of s c product versions 170 * @param end the upper bound of the range of s c product versions (not inclusive) 171 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 172 * @param retrieveFromCache whether to retrieve from the finder cache 173 * @return the ordered range of matching s c product versions 174 */ 175 public static List<SCProductVersion> findByProductEntryId( 176 long productEntryId, int start, int end, 177 OrderByComparator<SCProductVersion> orderByComparator, 178 boolean retrieveFromCache) { 179 return getPersistence() 180 .findByProductEntryId(productEntryId, start, end, 181 orderByComparator, retrieveFromCache); 182 } 183 184 /** 185 * Returns the first s c product version in the ordered set where productEntryId = ?. 186 * 187 * @param productEntryId the product entry ID 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the first matching s c product version 190 * @throws NoSuchProductVersionException if a matching s c product version could not be found 191 */ 192 public static SCProductVersion findByProductEntryId_First( 193 long productEntryId, 194 OrderByComparator<SCProductVersion> orderByComparator) 195 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 196 return getPersistence() 197 .findByProductEntryId_First(productEntryId, orderByComparator); 198 } 199 200 /** 201 * Returns the first s c product version in the ordered set where productEntryId = ?. 202 * 203 * @param productEntryId the product entry ID 204 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 205 * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found 206 */ 207 public static SCProductVersion fetchByProductEntryId_First( 208 long productEntryId, 209 OrderByComparator<SCProductVersion> orderByComparator) { 210 return getPersistence() 211 .fetchByProductEntryId_First(productEntryId, 212 orderByComparator); 213 } 214 215 /** 216 * Returns the last s c product version in the ordered set where productEntryId = ?. 217 * 218 * @param productEntryId the product entry ID 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching s c product version 221 * @throws NoSuchProductVersionException if a matching s c product version could not be found 222 */ 223 public static SCProductVersion findByProductEntryId_Last( 224 long productEntryId, 225 OrderByComparator<SCProductVersion> orderByComparator) 226 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 227 return getPersistence() 228 .findByProductEntryId_Last(productEntryId, orderByComparator); 229 } 230 231 /** 232 * Returns the last s c product version in the ordered set where productEntryId = ?. 233 * 234 * @param productEntryId the product entry ID 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found 237 */ 238 public static SCProductVersion fetchByProductEntryId_Last( 239 long productEntryId, 240 OrderByComparator<SCProductVersion> orderByComparator) { 241 return getPersistence() 242 .fetchByProductEntryId_Last(productEntryId, orderByComparator); 243 } 244 245 /** 246 * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = ?. 247 * 248 * @param productVersionId the primary key of the current s c product version 249 * @param productEntryId the product entry ID 250 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 251 * @return the previous, current, and next s c product version 252 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 253 */ 254 public static SCProductVersion[] findByProductEntryId_PrevAndNext( 255 long productVersionId, long productEntryId, 256 OrderByComparator<SCProductVersion> orderByComparator) 257 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 258 return getPersistence() 259 .findByProductEntryId_PrevAndNext(productVersionId, 260 productEntryId, orderByComparator); 261 } 262 263 /** 264 * Removes all the s c product versions where productEntryId = ? from the database. 265 * 266 * @param productEntryId the product entry ID 267 */ 268 public static void removeByProductEntryId(long productEntryId) { 269 getPersistence().removeByProductEntryId(productEntryId); 270 } 271 272 /** 273 * Returns the number of s c product versions where productEntryId = ?. 274 * 275 * @param productEntryId the product entry ID 276 * @return the number of matching s c product versions 277 */ 278 public static int countByProductEntryId(long productEntryId) { 279 return getPersistence().countByProductEntryId(productEntryId); 280 } 281 282 /** 283 * Returns the s c product version where directDownloadURL = ? or throws a {@link NoSuchProductVersionException} if it could not be found. 284 * 285 * @param directDownloadURL the direct download u r l 286 * @return the matching s c product version 287 * @throws NoSuchProductVersionException if a matching s c product version could not be found 288 */ 289 public static SCProductVersion findByDirectDownloadURL( 290 java.lang.String directDownloadURL) 291 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 292 return getPersistence().findByDirectDownloadURL(directDownloadURL); 293 } 294 295 /** 296 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 297 * 298 * @param directDownloadURL the direct download u r l 299 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 300 */ 301 public static SCProductVersion fetchByDirectDownloadURL( 302 java.lang.String directDownloadURL) { 303 return getPersistence().fetchByDirectDownloadURL(directDownloadURL); 304 } 305 306 /** 307 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 308 * 309 * @param directDownloadURL the direct download u r l 310 * @param retrieveFromCache whether to retrieve from the finder cache 311 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 312 */ 313 public static SCProductVersion fetchByDirectDownloadURL( 314 java.lang.String directDownloadURL, boolean retrieveFromCache) { 315 return getPersistence() 316 .fetchByDirectDownloadURL(directDownloadURL, 317 retrieveFromCache); 318 } 319 320 /** 321 * Removes the s c product version where directDownloadURL = ? from the database. 322 * 323 * @param directDownloadURL the direct download u r l 324 * @return the s c product version that was removed 325 */ 326 public static SCProductVersion removeByDirectDownloadURL( 327 java.lang.String directDownloadURL) 328 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 329 return getPersistence().removeByDirectDownloadURL(directDownloadURL); 330 } 331 332 /** 333 * Returns the number of s c product versions where directDownloadURL = ?. 334 * 335 * @param directDownloadURL the direct download u r l 336 * @return the number of matching s c product versions 337 */ 338 public static int countByDirectDownloadURL( 339 java.lang.String directDownloadURL) { 340 return getPersistence().countByDirectDownloadURL(directDownloadURL); 341 } 342 343 /** 344 * Caches the s c product version in the entity cache if it is enabled. 345 * 346 * @param scProductVersion the s c product version 347 */ 348 public static void cacheResult(SCProductVersion scProductVersion) { 349 getPersistence().cacheResult(scProductVersion); 350 } 351 352 /** 353 * Caches the s c product versions in the entity cache if it is enabled. 354 * 355 * @param scProductVersions the s c product versions 356 */ 357 public static void cacheResult(List<SCProductVersion> scProductVersions) { 358 getPersistence().cacheResult(scProductVersions); 359 } 360 361 /** 362 * Creates a new s c product version with the primary key. Does not add the s c product version to the database. 363 * 364 * @param productVersionId the primary key for the new s c product version 365 * @return the new s c product version 366 */ 367 public static SCProductVersion create(long productVersionId) { 368 return getPersistence().create(productVersionId); 369 } 370 371 /** 372 * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners. 373 * 374 * @param productVersionId the primary key of the s c product version 375 * @return the s c product version that was removed 376 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 377 */ 378 public static SCProductVersion remove(long productVersionId) 379 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 380 return getPersistence().remove(productVersionId); 381 } 382 383 public static SCProductVersion updateImpl(SCProductVersion scProductVersion) { 384 return getPersistence().updateImpl(scProductVersion); 385 } 386 387 /** 388 * Returns the s c product version with the primary key or throws a {@link NoSuchProductVersionException} if it could not be found. 389 * 390 * @param productVersionId the primary key of the s c product version 391 * @return the s c product version 392 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 393 */ 394 public static SCProductVersion findByPrimaryKey(long productVersionId) 395 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 396 return getPersistence().findByPrimaryKey(productVersionId); 397 } 398 399 /** 400 * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found. 401 * 402 * @param productVersionId the primary key of the s c product version 403 * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found 404 */ 405 public static SCProductVersion fetchByPrimaryKey(long productVersionId) { 406 return getPersistence().fetchByPrimaryKey(productVersionId); 407 } 408 409 public static java.util.Map<java.io.Serializable, SCProductVersion> fetchByPrimaryKeys( 410 java.util.Set<java.io.Serializable> primaryKeys) { 411 return getPersistence().fetchByPrimaryKeys(primaryKeys); 412 } 413 414 /** 415 * Returns all the s c product versions. 416 * 417 * @return the s c product versions 418 */ 419 public static List<SCProductVersion> findAll() { 420 return getPersistence().findAll(); 421 } 422 423 /** 424 * Returns a range of all the s c product versions. 425 * 426 * <p> 427 * 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 SCProductVersionModelImpl}. 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. 428 * </p> 429 * 430 * @param start the lower bound of the range of s c product versions 431 * @param end the upper bound of the range of s c product versions (not inclusive) 432 * @return the range of s c product versions 433 */ 434 public static List<SCProductVersion> findAll(int start, int end) { 435 return getPersistence().findAll(start, end); 436 } 437 438 /** 439 * Returns an ordered range of all the s c product versions. 440 * 441 * <p> 442 * 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 SCProductVersionModelImpl}. 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. 443 * </p> 444 * 445 * @param start the lower bound of the range of s c product versions 446 * @param end the upper bound of the range of s c product versions (not inclusive) 447 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 448 * @return the ordered range of s c product versions 449 */ 450 public static List<SCProductVersion> findAll(int start, int end, 451 OrderByComparator<SCProductVersion> orderByComparator) { 452 return getPersistence().findAll(start, end, orderByComparator); 453 } 454 455 /** 456 * Returns an ordered range of all the s c product versions. 457 * 458 * <p> 459 * 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 SCProductVersionModelImpl}. 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. 460 * </p> 461 * 462 * @param start the lower bound of the range of s c product versions 463 * @param end the upper bound of the range of s c product versions (not inclusive) 464 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 465 * @param retrieveFromCache whether to retrieve from the finder cache 466 * @return the ordered range of s c product versions 467 */ 468 public static List<SCProductVersion> findAll(int start, int end, 469 OrderByComparator<SCProductVersion> orderByComparator, 470 boolean retrieveFromCache) { 471 return getPersistence() 472 .findAll(start, end, orderByComparator, retrieveFromCache); 473 } 474 475 /** 476 * Removes all the s c product versions from the database. 477 */ 478 public static void removeAll() { 479 getPersistence().removeAll(); 480 } 481 482 /** 483 * Returns the number of s c product versions. 484 * 485 * @return the number of s c product versions 486 */ 487 public static int countAll() { 488 return getPersistence().countAll(); 489 } 490 491 /** 492 * Returns the primaryKeys of s c framework versions associated with the s c product version. 493 * 494 * @param pk the primary key of the s c product version 495 * @return long[] of the primaryKeys of s c framework versions associated with the s c product version 496 */ 497 public static long[] getSCFrameworkVersionPrimaryKeys(long pk) { 498 return getPersistence().getSCFrameworkVersionPrimaryKeys(pk); 499 } 500 501 /** 502 * Returns all the s c framework versions associated with the s c product version. 503 * 504 * @param pk the primary key of the s c product version 505 * @return the s c framework versions associated with the s c product version 506 */ 507 public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 508 long pk) { 509 return getPersistence().getSCFrameworkVersions(pk); 510 } 511 512 /** 513 * Returns a range of all the s c framework versions associated with the s c product version. 514 * 515 * <p> 516 * 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 SCProductVersionModelImpl}. 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. 517 * </p> 518 * 519 * @param pk the primary key of the s c product version 520 * @param start the lower bound of the range of s c product versions 521 * @param end the upper bound of the range of s c product versions (not inclusive) 522 * @return the range of s c framework versions associated with the s c product version 523 */ 524 public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 525 long pk, int start, int end) { 526 return getPersistence().getSCFrameworkVersions(pk, start, end); 527 } 528 529 /** 530 * Returns an ordered range of all the s c framework versions associated with the s c product version. 531 * 532 * <p> 533 * 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 SCProductVersionModelImpl}. 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. 534 * </p> 535 * 536 * @param pk the primary key of the s c product version 537 * @param start the lower bound of the range of s c product versions 538 * @param end the upper bound of the range of s c product versions (not inclusive) 539 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 540 * @return the ordered range of s c framework versions associated with the s c product version 541 */ 542 public static List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 543 long pk, int start, int end, 544 OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> orderByComparator) { 545 return getPersistence() 546 .getSCFrameworkVersions(pk, start, end, orderByComparator); 547 } 548 549 /** 550 * Returns the number of s c framework versions associated with the s c product version. 551 * 552 * @param pk the primary key of the s c product version 553 * @return the number of s c framework versions associated with the s c product version 554 */ 555 public static int getSCFrameworkVersionsSize(long pk) { 556 return getPersistence().getSCFrameworkVersionsSize(pk); 557 } 558 559 /** 560 * Returns <code>true</code> if the s c framework version is associated with the s c product version. 561 * 562 * @param pk the primary key of the s c product version 563 * @param scFrameworkVersionPK the primary key of the s c framework version 564 * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise 565 */ 566 public static boolean containsSCFrameworkVersion(long pk, 567 long scFrameworkVersionPK) { 568 return getPersistence() 569 .containsSCFrameworkVersion(pk, scFrameworkVersionPK); 570 } 571 572 /** 573 * Returns <code>true</code> if the s c product version has any s c framework versions associated with it. 574 * 575 * @param pk the primary key of the s c product version to check for associations with s c framework versions 576 * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise 577 */ 578 public static boolean containsSCFrameworkVersions(long pk) { 579 return getPersistence().containsSCFrameworkVersions(pk); 580 } 581 582 /** 583 * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 584 * 585 * @param pk the primary key of the s c product version 586 * @param scFrameworkVersionPK the primary key of the s c framework version 587 */ 588 public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK) { 589 getPersistence().addSCFrameworkVersion(pk, scFrameworkVersionPK); 590 } 591 592 /** 593 * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 594 * 595 * @param pk the primary key of the s c product version 596 * @param scFrameworkVersion the s c framework version 597 */ 598 public static void addSCFrameworkVersion(long pk, 599 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) { 600 getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion); 601 } 602 603 /** 604 * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 605 * 606 * @param pk the primary key of the s c product version 607 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 608 */ 609 public static void addSCFrameworkVersions(long pk, 610 long[] scFrameworkVersionPKs) { 611 getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs); 612 } 613 614 /** 615 * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 616 * 617 * @param pk the primary key of the s c product version 618 * @param scFrameworkVersions the s c framework versions 619 */ 620 public static void addSCFrameworkVersions(long pk, 621 List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) { 622 getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions); 623 } 624 625 /** 626 * Clears all associations between the s c product version and its s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 627 * 628 * @param pk the primary key of the s c product version to clear the associated s c framework versions from 629 */ 630 public static void clearSCFrameworkVersions(long pk) { 631 getPersistence().clearSCFrameworkVersions(pk); 632 } 633 634 /** 635 * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 636 * 637 * @param pk the primary key of the s c product version 638 * @param scFrameworkVersionPK the primary key of the s c framework version 639 */ 640 public static void removeSCFrameworkVersion(long pk, 641 long scFrameworkVersionPK) { 642 getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK); 643 } 644 645 /** 646 * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 647 * 648 * @param pk the primary key of the s c product version 649 * @param scFrameworkVersion the s c framework version 650 */ 651 public static void removeSCFrameworkVersion(long pk, 652 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) { 653 getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion); 654 } 655 656 /** 657 * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 658 * 659 * @param pk the primary key of the s c product version 660 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 661 */ 662 public static void removeSCFrameworkVersions(long pk, 663 long[] scFrameworkVersionPKs) { 664 getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs); 665 } 666 667 /** 668 * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 669 * 670 * @param pk the primary key of the s c product version 671 * @param scFrameworkVersions the s c framework versions 672 */ 673 public static void removeSCFrameworkVersions(long pk, 674 List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) { 675 getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions); 676 } 677 678 /** 679 * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 680 * 681 * @param pk the primary key of the s c product version 682 * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version 683 */ 684 public static void setSCFrameworkVersions(long pk, 685 long[] scFrameworkVersionPKs) { 686 getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs); 687 } 688 689 /** 690 * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 691 * 692 * @param pk the primary key of the s c product version 693 * @param scFrameworkVersions the s c framework versions to be associated with the s c product version 694 */ 695 public static void setSCFrameworkVersions(long pk, 696 List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) { 697 getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions); 698 } 699 700 public static SCProductVersionPersistence getPersistence() { 701 if (_persistence == null) { 702 _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName()); 703 704 ReferenceRegistry.registerReference(SCProductVersionUtil.class, 705 "_persistence"); 706 } 707 708 return _persistence; 709 } 710 711 /** 712 * @deprecated As of 6.2.0 713 */ 714 @Deprecated 715 public void setPersistence(SCProductVersionPersistence persistence) { 716 } 717 718 private static SCProductVersionPersistence _persistence; 719 }