001 /** 002 * Copyright (c) 2000-2010 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.service.ServiceContext; 022 023 import com.liferay.portlet.softwarecatalog.model.SCProductVersion; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the s c product version service. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class. 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see SCProductVersionPersistence 036 * @see SCProductVersionPersistenceImpl 037 * @generated 038 */ 039 public class SCProductVersionUtil { 040 /** 041 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 042 */ 043 public static void clearCache() { 044 getPersistence().clearCache(); 045 } 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 049 */ 050 public static void clearCache(SCProductVersion scProductVersion) { 051 getPersistence().clearCache(scProductVersion); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 056 */ 057 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 058 throws SystemException { 059 return getPersistence().countWithDynamicQuery(dynamicQuery); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 064 */ 065 public static List<SCProductVersion> findWithDynamicQuery( 066 DynamicQuery dynamicQuery) throws SystemException { 067 return getPersistence().findWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 072 */ 073 public static List<SCProductVersion> findWithDynamicQuery( 074 DynamicQuery dynamicQuery, int start, int end) 075 throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 081 */ 082 public static List<SCProductVersion> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end, 084 OrderByComparator orderByComparator) throws SystemException { 085 return getPersistence() 086 .findWithDynamicQuery(dynamicQuery, start, end, 087 orderByComparator); 088 } 089 090 /** 091 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 092 */ 093 public static SCProductVersion remove(SCProductVersion scProductVersion) 094 throws SystemException { 095 return getPersistence().remove(scProductVersion); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 100 */ 101 public static SCProductVersion update(SCProductVersion scProductVersion, 102 boolean merge) throws SystemException { 103 return getPersistence().update(scProductVersion, merge); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 108 */ 109 public static SCProductVersion update(SCProductVersion scProductVersion, 110 boolean merge, ServiceContext serviceContext) throws SystemException { 111 return getPersistence().update(scProductVersion, merge, serviceContext); 112 } 113 114 /** 115 * Caches the s c product version in the entity cache if it is enabled. 116 * 117 * @param scProductVersion the s c product version to cache 118 */ 119 public static void cacheResult( 120 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) { 121 getPersistence().cacheResult(scProductVersion); 122 } 123 124 /** 125 * Caches the s c product versions in the entity cache if it is enabled. 126 * 127 * @param scProductVersions the s c product versions to cache 128 */ 129 public static void cacheResult( 130 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) { 131 getPersistence().cacheResult(scProductVersions); 132 } 133 134 /** 135 * Creates a new s c product version with the primary key. 136 * 137 * @param productVersionId the primary key for the new s c product version 138 * @return the new s c product version 139 */ 140 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion create( 141 long productVersionId) { 142 return getPersistence().create(productVersionId); 143 } 144 145 /** 146 * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners. 147 * 148 * @param productVersionId the primary key of the s c product version to remove 149 * @return the s c product version that was removed 150 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion remove( 154 long productVersionId) 155 throws com.liferay.portal.kernel.exception.SystemException, 156 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 157 return getPersistence().remove(productVersionId); 158 } 159 160 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion updateImpl( 161 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion, 162 boolean merge) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence().updateImpl(scProductVersion, merge); 165 } 166 167 /** 168 * Finds the s c product version with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found. 169 * 170 * @param productVersionId the primary key of the s c product version to find 171 * @return the s c product version 172 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByPrimaryKey( 176 long productVersionId) 177 throws com.liferay.portal.kernel.exception.SystemException, 178 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 179 return getPersistence().findByPrimaryKey(productVersionId); 180 } 181 182 /** 183 * Finds the s c product version with the primary key or returns <code>null</code> if it could not be found. 184 * 185 * @param productVersionId the primary key of the s c product version to find 186 * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found 187 * @throws SystemException if a system exception occurred 188 */ 189 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByPrimaryKey( 190 long productVersionId) 191 throws com.liferay.portal.kernel.exception.SystemException { 192 return getPersistence().fetchByPrimaryKey(productVersionId); 193 } 194 195 /** 196 * Finds all the s c product versions where productEntryId = ?. 197 * 198 * @param productEntryId the product entry id to search with 199 * @return the matching s c product versions 200 * @throws SystemException if a system exception occurred 201 */ 202 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId( 203 long productEntryId) 204 throws com.liferay.portal.kernel.exception.SystemException { 205 return getPersistence().findByProductEntryId(productEntryId); 206 } 207 208 /** 209 * Finds a range of all the s c product versions where productEntryId = ?. 210 * 211 * <p> 212 * 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. 213 * </p> 214 * 215 * @param productEntryId the product entry id to search with 216 * @param start the lower bound of the range of s c product versions to return 217 * @param end the upper bound of the range of s c product versions to return (not inclusive) 218 * @return the range of matching s c product versions 219 * @throws SystemException if a system exception occurred 220 */ 221 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId( 222 long productEntryId, int start, int end) 223 throws com.liferay.portal.kernel.exception.SystemException { 224 return getPersistence().findByProductEntryId(productEntryId, start, end); 225 } 226 227 /** 228 * Finds an ordered range of all the s c product versions where productEntryId = ?. 229 * 230 * <p> 231 * 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. 232 * </p> 233 * 234 * @param productEntryId the product entry id to search with 235 * @param start the lower bound of the range of s c product versions to return 236 * @param end the upper bound of the range of s c product versions to return (not inclusive) 237 * @param orderByComparator the comparator to order the results by 238 * @return the ordered range of matching s c product versions 239 * @throws SystemException if a system exception occurred 240 */ 241 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId( 242 long productEntryId, int start, int end, 243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 244 throws com.liferay.portal.kernel.exception.SystemException { 245 return getPersistence() 246 .findByProductEntryId(productEntryId, start, end, 247 orderByComparator); 248 } 249 250 /** 251 * Finds the first s c product version in the ordered set where productEntryId = ?. 252 * 253 * <p> 254 * 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. 255 * </p> 256 * 257 * @param productEntryId the product entry id to search with 258 * @param orderByComparator the comparator to order the set by 259 * @return the first matching s c product version 260 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found 261 * @throws SystemException if a system exception occurred 262 */ 263 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_First( 264 long productEntryId, 265 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 266 throws com.liferay.portal.kernel.exception.SystemException, 267 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 268 return getPersistence() 269 .findByProductEntryId_First(productEntryId, orderByComparator); 270 } 271 272 /** 273 * Finds the last s c product version in the ordered set where productEntryId = ?. 274 * 275 * <p> 276 * 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. 277 * </p> 278 * 279 * @param productEntryId the product entry id to search with 280 * @param orderByComparator the comparator to order the set by 281 * @return the last matching s c product version 282 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found 283 * @throws SystemException if a system exception occurred 284 */ 285 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_Last( 286 long productEntryId, 287 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 288 throws com.liferay.portal.kernel.exception.SystemException, 289 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 290 return getPersistence() 291 .findByProductEntryId_Last(productEntryId, orderByComparator); 292 } 293 294 /** 295 * Finds the s c product versions before and after the current s c product version in the ordered set where productEntryId = ?. 296 * 297 * <p> 298 * 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. 299 * </p> 300 * 301 * @param productVersionId the primary key of the current s c product version 302 * @param productEntryId the product entry id to search with 303 * @param orderByComparator the comparator to order the set by 304 * @return the previous, current, and next s c product version 305 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found 306 * @throws SystemException if a system exception occurred 307 */ 308 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion[] findByProductEntryId_PrevAndNext( 309 long productVersionId, long productEntryId, 310 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 311 throws com.liferay.portal.kernel.exception.SystemException, 312 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 313 return getPersistence() 314 .findByProductEntryId_PrevAndNext(productVersionId, 315 productEntryId, orderByComparator); 316 } 317 318 /** 319 * Finds the s c product version where directDownloadURL = ? or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found. 320 * 321 * @param directDownloadURL the direct download u r l to search with 322 * @return the matching s c product version 323 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found 324 * @throws SystemException if a system exception occurred 325 */ 326 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByDirectDownloadURL( 327 java.lang.String directDownloadURL) 328 throws com.liferay.portal.kernel.exception.SystemException, 329 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 330 return getPersistence().findByDirectDownloadURL(directDownloadURL); 331 } 332 333 /** 334 * Finds the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 335 * 336 * @param directDownloadURL the direct download u r l to search with 337 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 338 * @throws SystemException if a system exception occurred 339 */ 340 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL( 341 java.lang.String directDownloadURL) 342 throws com.liferay.portal.kernel.exception.SystemException { 343 return getPersistence().fetchByDirectDownloadURL(directDownloadURL); 344 } 345 346 /** 347 * Finds the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 348 * 349 * @param directDownloadURL the direct download u r l to search with 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 * Finds 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 * Finds 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 to return 380 * @param end the upper bound of the range of s c product versions to return (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 * Finds 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 to return 398 * @param end the upper bound of the range of s c product versions to return (not inclusive) 399 * @param orderByComparator the comparator to order the results by 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 to search with 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 to search with 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 * Counts all the s c product versions where productEntryId = ?. 446 * 447 * @param productEntryId the product entry id to search with 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 * Counts all the s c product versions where directDownloadURL = ?. 458 * 459 * @param directDownloadURL the direct download u r l to search with 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 * Counts all the 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 * Gets 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 to get the associated s c framework versions for 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 * Gets 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 to get the associated s c framework versions for 500 * @param start the lower bound of the range of s c product versions to return 501 * @param end the upper bound of the range of s c product versions to return (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 * Gets 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 to get the associated s c framework versions for 519 * @param start the lower bound of the range of s c product versions to return 520 * @param end the upper bound of the range of s c product versions to return (not inclusive) 521 * @param orderByComparator the comparator to order the results by 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 * Gets 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 to get the number of associated s c framework versions for 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 * Determines whether 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 whether the s c framework version is associated with the s c product version 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 * Determines whether 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 whether the s c product version has any s c framework versions associated with it 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 to set the associations for 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 to set the associations for 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 717 return _persistence; 718 } 719 720 public void setPersistence(SCProductVersionPersistence persistence) { 721 _persistence = persistence; 722 } 723 724 private static SCProductVersionPersistence _persistence; 725 }