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