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