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