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) 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 * Returns all the s c product versions where productEntryId = ?. 115 * 116 * @param productEntryId the product entry ID 117 * @return the matching s c product versions 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId( 121 long productEntryId) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByProductEntryId(productEntryId); 124 } 125 126 /** 127 * Returns a range of all the s c product versions where productEntryId = ?. 128 * 129 * <p> 130 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param productEntryId the product entry ID 134 * @param start the lower bound of the range of s c product versions 135 * @param end the upper bound of the range of s c product versions (not inclusive) 136 * @return the range of matching s c product versions 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId( 140 long productEntryId, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByProductEntryId(productEntryId, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the s c product versions where productEntryId = ?. 147 * 148 * <p> 149 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 150 * </p> 151 * 152 * @param productEntryId the product entry ID 153 * @param start the lower bound of the range of s c product versions 154 * @param end the upper bound of the range of s c product versions (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching s c product versions 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findByProductEntryId( 160 long productEntryId, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence() 164 .findByProductEntryId(productEntryId, start, end, 165 orderByComparator); 166 } 167 168 /** 169 * Returns the first s c product version in the ordered set where productEntryId = ?. 170 * 171 * @param productEntryId the product entry ID 172 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 173 * @return the first matching s c product version 174 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found 175 * @throws SystemException if a system exception occurred 176 */ 177 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_First( 178 long productEntryId, 179 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 180 throws com.liferay.portal.kernel.exception.SystemException, 181 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 182 return getPersistence() 183 .findByProductEntryId_First(productEntryId, orderByComparator); 184 } 185 186 /** 187 * Returns the first s c product version in the ordered set where productEntryId = ?. 188 * 189 * @param productEntryId the product entry ID 190 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 191 * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found 192 * @throws SystemException if a system exception occurred 193 */ 194 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByProductEntryId_First( 195 long productEntryId, 196 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 197 throws com.liferay.portal.kernel.exception.SystemException { 198 return getPersistence() 199 .fetchByProductEntryId_First(productEntryId, 200 orderByComparator); 201 } 202 203 /** 204 * Returns the last s c product version in the ordered set where productEntryId = ?. 205 * 206 * @param productEntryId the product entry ID 207 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 208 * @return the last matching s c product version 209 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found 210 * @throws SystemException if a system exception occurred 211 */ 212 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByProductEntryId_Last( 213 long productEntryId, 214 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 215 throws com.liferay.portal.kernel.exception.SystemException, 216 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 217 return getPersistence() 218 .findByProductEntryId_Last(productEntryId, orderByComparator); 219 } 220 221 /** 222 * Returns the last s c product version in the ordered set where productEntryId = ?. 223 * 224 * @param productEntryId the product entry ID 225 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 226 * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found 227 * @throws SystemException if a system exception occurred 228 */ 229 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByProductEntryId_Last( 230 long productEntryId, 231 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 232 throws com.liferay.portal.kernel.exception.SystemException { 233 return getPersistence() 234 .fetchByProductEntryId_Last(productEntryId, orderByComparator); 235 } 236 237 /** 238 * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = ?. 239 * 240 * @param productVersionId the primary key of the current s c product version 241 * @param productEntryId the product entry ID 242 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 243 * @return the previous, current, and next s c product version 244 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found 245 * @throws SystemException if a system exception occurred 246 */ 247 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion[] findByProductEntryId_PrevAndNext( 248 long productVersionId, long productEntryId, 249 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 250 throws com.liferay.portal.kernel.exception.SystemException, 251 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 252 return getPersistence() 253 .findByProductEntryId_PrevAndNext(productVersionId, 254 productEntryId, orderByComparator); 255 } 256 257 /** 258 * Removes all the s c product versions where productEntryId = ? from the database. 259 * 260 * @param productEntryId the product entry ID 261 * @throws SystemException if a system exception occurred 262 */ 263 public static void removeByProductEntryId(long productEntryId) 264 throws com.liferay.portal.kernel.exception.SystemException { 265 getPersistence().removeByProductEntryId(productEntryId); 266 } 267 268 /** 269 * Returns the number of s c product versions where productEntryId = ?. 270 * 271 * @param productEntryId the product entry ID 272 * @return the number of matching s c product versions 273 * @throws SystemException if a system exception occurred 274 */ 275 public static int countByProductEntryId(long productEntryId) 276 throws com.liferay.portal.kernel.exception.SystemException { 277 return getPersistence().countByProductEntryId(productEntryId); 278 } 279 280 /** 281 * Returns the s c product version where directDownloadURL = ? or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchProductVersionException} if it could not be found. 282 * 283 * @param directDownloadURL the direct download u r l 284 * @return the matching s c product version 285 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a matching s c product version could not be found 286 * @throws SystemException if a system exception occurred 287 */ 288 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByDirectDownloadURL( 289 java.lang.String directDownloadURL) 290 throws com.liferay.portal.kernel.exception.SystemException, 291 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 292 return getPersistence().findByDirectDownloadURL(directDownloadURL); 293 } 294 295 /** 296 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 297 * 298 * @param directDownloadURL the direct download u r l 299 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 300 * @throws SystemException if a system exception occurred 301 */ 302 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL( 303 java.lang.String directDownloadURL) 304 throws com.liferay.portal.kernel.exception.SystemException { 305 return getPersistence().fetchByDirectDownloadURL(directDownloadURL); 306 } 307 308 /** 309 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 310 * 311 * @param directDownloadURL the direct download u r l 312 * @param retrieveFromCache whether to use the finder cache 313 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 314 * @throws SystemException if a system exception occurred 315 */ 316 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByDirectDownloadURL( 317 java.lang.String directDownloadURL, boolean retrieveFromCache) 318 throws com.liferay.portal.kernel.exception.SystemException { 319 return getPersistence() 320 .fetchByDirectDownloadURL(directDownloadURL, 321 retrieveFromCache); 322 } 323 324 /** 325 * Removes the s c product version where directDownloadURL = ? from the database. 326 * 327 * @param directDownloadURL the direct download u r l 328 * @return the s c product version that was removed 329 * @throws SystemException if a system exception occurred 330 */ 331 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion removeByDirectDownloadURL( 332 java.lang.String directDownloadURL) 333 throws com.liferay.portal.kernel.exception.SystemException, 334 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 335 return getPersistence().removeByDirectDownloadURL(directDownloadURL); 336 } 337 338 /** 339 * Returns the number of s c product versions where directDownloadURL = ?. 340 * 341 * @param directDownloadURL the direct download u r l 342 * @return the number of matching s c product versions 343 * @throws SystemException if a system exception occurred 344 */ 345 public static int countByDirectDownloadURL( 346 java.lang.String directDownloadURL) 347 throws com.liferay.portal.kernel.exception.SystemException { 348 return getPersistence().countByDirectDownloadURL(directDownloadURL); 349 } 350 351 /** 352 * Caches the s c product version in the entity cache if it is enabled. 353 * 354 * @param scProductVersion the s c product version 355 */ 356 public static void cacheResult( 357 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) { 358 getPersistence().cacheResult(scProductVersion); 359 } 360 361 /** 362 * Caches the s c product versions in the entity cache if it is enabled. 363 * 364 * @param scProductVersions the s c product versions 365 */ 366 public static void cacheResult( 367 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) { 368 getPersistence().cacheResult(scProductVersions); 369 } 370 371 /** 372 * Creates a new s c product version with the primary key. Does not add the s c product version to the database. 373 * 374 * @param productVersionId the primary key for the new s c product version 375 * @return the new s c product version 376 */ 377 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion create( 378 long productVersionId) { 379 return getPersistence().create(productVersionId); 380 } 381 382 /** 383 * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners. 384 * 385 * @param productVersionId the primary key of the s c product version 386 * @return the s c product version that was removed 387 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found 388 * @throws SystemException if a system exception occurred 389 */ 390 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion remove( 391 long productVersionId) 392 throws com.liferay.portal.kernel.exception.SystemException, 393 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 394 return getPersistence().remove(productVersionId); 395 } 396 397 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion updateImpl( 398 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 399 throws com.liferay.portal.kernel.exception.SystemException { 400 return getPersistence().updateImpl(scProductVersion); 401 } 402 403 /** 404 * 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. 405 * 406 * @param productVersionId the primary key of the s c product version 407 * @return the s c product version 408 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException if a s c product version with the primary key could not be found 409 * @throws SystemException if a system exception occurred 410 */ 411 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion findByPrimaryKey( 412 long productVersionId) 413 throws com.liferay.portal.kernel.exception.SystemException, 414 com.liferay.portlet.softwarecatalog.NoSuchProductVersionException { 415 return getPersistence().findByPrimaryKey(productVersionId); 416 } 417 418 /** 419 * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found. 420 * 421 * @param productVersionId the primary key of the s c product version 422 * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found 423 * @throws SystemException if a system exception occurred 424 */ 425 public static com.liferay.portlet.softwarecatalog.model.SCProductVersion fetchByPrimaryKey( 426 long productVersionId) 427 throws com.liferay.portal.kernel.exception.SystemException { 428 return getPersistence().fetchByPrimaryKey(productVersionId); 429 } 430 431 /** 432 * Returns all the s c product versions. 433 * 434 * @return the s c product versions 435 * @throws SystemException if a system exception occurred 436 */ 437 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll() 438 throws com.liferay.portal.kernel.exception.SystemException { 439 return getPersistence().findAll(); 440 } 441 442 /** 443 * Returns a range of all the s c product versions. 444 * 445 * <p> 446 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 447 * </p> 448 * 449 * @param start the lower bound of the range of s c product versions 450 * @param end the upper bound of the range of s c product versions (not inclusive) 451 * @return the range of s c product versions 452 * @throws SystemException if a system exception occurred 453 */ 454 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll( 455 int start, int end) 456 throws com.liferay.portal.kernel.exception.SystemException { 457 return getPersistence().findAll(start, end); 458 } 459 460 /** 461 * Returns an ordered range of all the s c product versions. 462 * 463 * <p> 464 * 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 465 * </p> 466 * 467 * @param start the lower bound of the range of s c product versions 468 * @param end the upper bound of the range of s c product versions (not inclusive) 469 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 470 * @return the ordered range of s c product versions 471 * @throws SystemException if a system exception occurred 472 */ 473 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> findAll( 474 int start, int end, 475 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 476 throws com.liferay.portal.kernel.exception.SystemException { 477 return getPersistence().findAll(start, end, orderByComparator); 478 } 479 480 /** 481 * Removes all the s c product versions from the database. 482 * 483 * @throws SystemException if a system exception occurred 484 */ 485 public static void removeAll() 486 throws com.liferay.portal.kernel.exception.SystemException { 487 getPersistence().removeAll(); 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 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 As of 6.2.0 746 */ 747 public void setPersistence(SCProductVersionPersistence persistence) { 748 } 749 750 private static SCProductVersionPersistence _persistence; 751 }