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