001 /** 002 * Copyright (c) 2000-2011 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#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 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 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 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 * 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. 176 * 177 * @param productVersionId the primary key of the s c product version 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 * Returns 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 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 * Returns all the s c product versions where productEntryId = ?. 204 * 205 * @param productEntryId the product entry ID 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 * Returns 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 223 * @param start the lower bound of the range of s c product versions 224 * @param end the upper bound of the range of s c product versions (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 * Returns 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 242 * @param start the lower bound of the range of s c product versions 243 * @param end the upper bound of the range of s c product versions (not inclusive) 244 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 265 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 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 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 310 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 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 * Returns 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 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 * Returns 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 357 * @param retrieveFromCache whether to use the finder cache 358 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 359 * @throws SystemException if a system exception occurred 360 */ 361 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL( 362 java.lang.String directDownloadURL, boolean retrieveFromCache) 363 throws com.liferay.portal.kernel.exception.SystemException { 364 return getPersistence() 365 .fetchByDirectDownloadURL(directDownloadURL, 366 retrieveFromCache); 367 } 368 369 /** 370 * Returns all the s c product versions. 371 * 372 * @return the s c product versions 373 * @throws SystemException if a system exception occurred 374 */ 375 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll() 376 throws com.liferay.portal.kernel.exception.SystemException { 377 return getPersistence().findAll(); 378 } 379 380 /** 381 * Returns a range of all the s c product versions. 382 * 383 * <p> 384 * 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. 385 * </p> 386 * 387 * @param start the lower bound of the range of s c product versions 388 * @param end the upper bound of the range of s c product versions (not inclusive) 389 * @return the range of s c product versions 390 * @throws SystemException if a system exception occurred 391 */ 392 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll( 393 int start, int end) 394 throws com.liferay.portal.kernel.exception.SystemException { 395 return getPersistence().findAll(start, end); 396 } 397 398 /** 399 * Returns an ordered range of all the s c product versions. 400 * 401 * <p> 402 * 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. 403 * </p> 404 * 405 * @param start the lower bound of the range of s c product versions 406 * @param end the upper bound of the range of s c product versions (not inclusive) 407 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 408 * @return the ordered range of s c product versions 409 * @throws SystemException if a system exception occurred 410 */ 411 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll( 412 int start, int end, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException { 415 return getPersistence().findAll(start, end, orderByComparator); 416 } 417 418 /** 419 * Removes all the s c product versions where productEntryId = ? from the database. 420 * 421 * @param productEntryId the product entry ID 422 * @throws SystemException if a system exception occurred 423 */ 424 public static void removeByProductEntryId(long productEntryId) 425 throws com.liferay.portal.kernel.exception.SystemException { 426 getPersistence().removeByProductEntryId(productEntryId); 427 } 428 429 /** 430 * Removes the s c product version where directDownloadURL = ? from the database. 431 * 432 * @param directDownloadURL the direct download u r l 433 * @throws SystemException if a system exception occurred 434 */ 435 public static void removeByDirectDownloadURL( 436 java.lang.String directDownloadURL) 437 throws com.liferay.portal.kernel.exception.SystemException, 438 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 439 getPersistence().removeByDirectDownloadURL(directDownloadURL); 440 } 441 442 /** 443 * Removes all the s c product versions from the database. 444 * 445 * @throws SystemException if a system exception occurred 446 */ 447 public static void removeAll() 448 throws com.liferay.portal.kernel.exception.SystemException { 449 getPersistence().removeAll(); 450 } 451 452 /** 453 * Returns the number of s c product versions where productEntryId = ?. 454 * 455 * @param productEntryId the product entry ID 456 * @return the number of matching s c product versions 457 * @throws SystemException if a system exception occurred 458 */ 459 public static int countByProductEntryId(long productEntryId) 460 throws com.liferay.portal.kernel.exception.SystemException { 461 return getPersistence().countByProductEntryId(productEntryId); 462 } 463 464 /** 465 * Returns the number of s c product versions where directDownloadURL = ?. 466 * 467 * @param directDownloadURL the direct download u r l 468 * @return the number of matching s c product versions 469 * @throws SystemException if a system exception occurred 470 */ 471 public static int countByDirectDownloadURL( 472 java.lang.String directDownloadURL) 473 throws com.liferay.portal.kernel.exception.SystemException { 474 return getPersistence().countByDirectDownloadURL(directDownloadURL); 475 } 476 477 /** 478 * Returns the number of s c product versions. 479 * 480 * @return the number of s c product versions 481 * @throws SystemException if a system exception occurred 482 */ 483 public static int countAll() 484 throws com.liferay.portal.kernel.exception.SystemException { 485 return getPersistence().countAll(); 486 } 487 488 /** 489 * Returns all the s c framework versions associated with the s c product version. 490 * 491 * @param pk the primary key of the s c product version 492 * @return the s c framework versions associated with the s c product version 493 * @throws SystemException if a system exception occurred 494 */ 495 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 496 long pk) throws com.liferay.portal.kernel.exception.SystemException { 497 return getPersistence().getSCFrameworkVersions(pk); 498 } 499 500 /** 501 * Returns a range of all the s c framework versions associated with the s c product version. 502 * 503 * <p> 504 * 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. 505 * </p> 506 * 507 * @param pk the primary key of the s c product version 508 * @param start the lower bound of the range of s c product versions 509 * @param end the upper bound of the range of s c product versions (not inclusive) 510 * @return the range of s c framework versions associated with the s c product version 511 * @throws SystemException if a system exception occurred 512 */ 513 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 514 long pk, int start, int end) 515 throws com.liferay.portal.kernel.exception.SystemException { 516 return getPersistence().getSCFrameworkVersions(pk, start, end); 517 } 518 519 /** 520 * Returns an ordered range of all the s c framework versions associated with the s c product version. 521 * 522 * <p> 523 * 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. 524 * </p> 525 * 526 * @param pk the primary key of the s c product version 527 * @param start the lower bound of the range of s c product versions 528 * @param end the upper bound of the range of s c product versions (not inclusive) 529 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 530 * @return the ordered range of s c framework versions associated with the s c product version 531 * @throws SystemException if a system exception occurred 532 */ 533 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 534 long pk, int start, int end, 535 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 536 throws com.liferay.portal.kernel.exception.SystemException { 537 return getPersistence() 538 .getSCFrameworkVersions(pk, start, end, orderByComparator); 539 } 540 541 /** 542 * Returns the number of s c framework versions associated with the s c product version. 543 * 544 * @param pk the primary key of the s c product version 545 * @return the number of s c framework versions associated with the s c product version 546 * @throws SystemException if a system exception occurred 547 */ 548 public static int getSCFrameworkVersionsSize(long pk) 549 throws com.liferay.portal.kernel.exception.SystemException { 550 return getPersistence().getSCFrameworkVersionsSize(pk); 551 } 552 553 /** 554 * Returns <code>true</code> if the s c framework version is associated with the s c product version. 555 * 556 * @param pk the primary key of the s c product version 557 * @param scFrameworkVersionPK the primary key of the s c framework version 558 * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise 559 * @throws SystemException if a system exception occurred 560 */ 561 public static boolean containsSCFrameworkVersion(long pk, 562 long scFrameworkVersionPK) 563 throws com.liferay.portal.kernel.exception.SystemException { 564 return getPersistence() 565 .containsSCFrameworkVersion(pk, scFrameworkVersionPK); 566 } 567 568 /** 569 * Returns <code>true</code> if the s c product version has any s c framework versions associated with it. 570 * 571 * @param pk the primary key of the s c product version to check for associations with s c framework versions 572 * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise 573 * @throws SystemException if a system exception occurred 574 */ 575 public static boolean containsSCFrameworkVersions(long pk) 576 throws com.liferay.portal.kernel.exception.SystemException { 577 return getPersistence().containsSCFrameworkVersions(pk); 578 } 579 580 /** 581 * 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. 582 * 583 * @param pk the primary key of the s c product version 584 * @param scFrameworkVersionPK the primary key of the s c framework version 585 * @throws SystemException if a system exception occurred 586 */ 587 public static void addSCFrameworkVersion(long pk, long scFrameworkVersionPK) 588 throws com.liferay.portal.kernel.exception.SystemException { 589 getPersistence().addSCFrameworkVersion(pk, scFrameworkVersionPK); 590 } 591 592 /** 593 * 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. 594 * 595 * @param pk the primary key of the s c product version 596 * @param scFrameworkVersion the s c framework version 597 * @throws SystemException if a system exception occurred 598 */ 599 public static void addSCFrameworkVersion(long pk, 600 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) 601 throws com.liferay.portal.kernel.exception.SystemException { 602 getPersistence().addSCFrameworkVersion(pk, scFrameworkVersion); 603 } 604 605 /** 606 * 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. 607 * 608 * @param pk the primary key of the s c product version 609 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 610 * @throws SystemException if a system exception occurred 611 */ 612 public static void addSCFrameworkVersions(long pk, 613 long[] scFrameworkVersionPKs) 614 throws com.liferay.portal.kernel.exception.SystemException { 615 getPersistence().addSCFrameworkVersions(pk, scFrameworkVersionPKs); 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 scFrameworkVersions the s c framework versions 623 * @throws SystemException if a system exception occurred 624 */ 625 public static void addSCFrameworkVersions(long pk, 626 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) 627 throws com.liferay.portal.kernel.exception.SystemException { 628 getPersistence().addSCFrameworkVersions(pk, scFrameworkVersions); 629 } 630 631 /** 632 * 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. 633 * 634 * @param pk the primary key of the s c product version to clear the associated s c framework versions from 635 * @throws SystemException if a system exception occurred 636 */ 637 public static void clearSCFrameworkVersions(long pk) 638 throws com.liferay.portal.kernel.exception.SystemException { 639 getPersistence().clearSCFrameworkVersions(pk); 640 } 641 642 /** 643 * 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. 644 * 645 * @param pk the primary key of the s c product version 646 * @param scFrameworkVersionPK the primary key of the s c framework version 647 * @throws SystemException if a system exception occurred 648 */ 649 public static void removeSCFrameworkVersion(long pk, 650 long scFrameworkVersionPK) 651 throws com.liferay.portal.kernel.exception.SystemException { 652 getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersionPK); 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 scFrameworkVersion the s c framework version 660 * @throws SystemException if a system exception occurred 661 */ 662 public static void removeSCFrameworkVersion(long pk, 663 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) 664 throws com.liferay.portal.kernel.exception.SystemException { 665 getPersistence().removeSCFrameworkVersion(pk, scFrameworkVersion); 666 } 667 668 /** 669 * 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. 670 * 671 * @param pk the primary key of the s c product version 672 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 673 * @throws SystemException if a system exception occurred 674 */ 675 public static void removeSCFrameworkVersions(long pk, 676 long[] scFrameworkVersionPKs) 677 throws com.liferay.portal.kernel.exception.SystemException { 678 getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersionPKs); 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 scFrameworkVersions the s c framework versions 686 * @throws SystemException if a system exception occurred 687 */ 688 public static void removeSCFrameworkVersions(long pk, 689 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) 690 throws com.liferay.portal.kernel.exception.SystemException { 691 getPersistence().removeSCFrameworkVersions(pk, scFrameworkVersions); 692 } 693 694 /** 695 * 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. 696 * 697 * @param pk the primary key of the s c product version 698 * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version 699 * @throws SystemException if a system exception occurred 700 */ 701 public static void setSCFrameworkVersions(long pk, 702 long[] scFrameworkVersionPKs) 703 throws com.liferay.portal.kernel.exception.SystemException { 704 getPersistence().setSCFrameworkVersions(pk, scFrameworkVersionPKs); 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 scFrameworkVersions 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 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) 716 throws com.liferay.portal.kernel.exception.SystemException { 717 getPersistence().setSCFrameworkVersions(pk, scFrameworkVersions); 718 } 719 720 public static SCProductVersionPersistence getPersistence() { 721 if (_persistence == null) { 722 _persistence = (SCProductVersionPersistence)PortalBeanLocatorUtil.locate(SCProductVersionPersistence.class.getName()); 723 724 ReferenceRegistry.registerReference(SCProductVersionUtil.class, 725 "_persistence"); 726 } 727 728 return _persistence; 729 } 730 731 public void setPersistence(SCProductVersionPersistence persistence) { 732 _persistence = persistence; 733 734 ReferenceRegistry.registerReference(SCProductVersionUtil.class, 735 "_persistence"); 736 } 737 738 private static SCProductVersionPersistence _persistence; 739 }