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