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