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