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