001 /** 002 * Copyright (c) 2000-2012 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.SCFrameworkVersion; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the s c framework version service. This utility wraps {@link SCFrameworkVersionPersistenceImpl} 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 SCFrameworkVersionPersistence 037 * @see SCFrameworkVersionPersistenceImpl 038 * @generated 039 */ 040 public class SCFrameworkVersionUtil { 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(SCFrameworkVersion scFrameworkVersion) { 058 getPersistence().clearCache(scFrameworkVersion); 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<SCFrameworkVersion> 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<SCFrameworkVersion> 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<SCFrameworkVersion> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 099 */ 100 public static SCFrameworkVersion update( 101 SCFrameworkVersion scFrameworkVersion, boolean merge) 102 throws SystemException { 103 return getPersistence().update(scFrameworkVersion, merge); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 108 */ 109 public static SCFrameworkVersion update( 110 SCFrameworkVersion scFrameworkVersion, boolean merge, 111 ServiceContext serviceContext) throws SystemException { 112 return getPersistence().update(scFrameworkVersion, merge, serviceContext); 113 } 114 115 /** 116 * Caches the s c framework version in the entity cache if it is enabled. 117 * 118 * @param scFrameworkVersion the s c framework version 119 */ 120 public static void cacheResult( 121 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) { 122 getPersistence().cacheResult(scFrameworkVersion); 123 } 124 125 /** 126 * Caches the s c framework versions in the entity cache if it is enabled. 127 * 128 * @param scFrameworkVersions the s c framework versions 129 */ 130 public static void cacheResult( 131 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions) { 132 getPersistence().cacheResult(scFrameworkVersions); 133 } 134 135 /** 136 * Creates a new s c framework version with the primary key. Does not add the s c framework version to the database. 137 * 138 * @param frameworkVersionId the primary key for the new s c framework version 139 * @return the new s c framework version 140 */ 141 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion create( 142 long frameworkVersionId) { 143 return getPersistence().create(frameworkVersionId); 144 } 145 146 /** 147 * Removes the s c framework version with the primary key from the database. Also notifies the appropriate model listeners. 148 * 149 * @param frameworkVersionId the primary key of the s c framework version 150 * @return the s c framework version that was removed 151 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 152 * @throws SystemException if a system exception occurred 153 */ 154 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion remove( 155 long frameworkVersionId) 156 throws com.liferay.portal.kernel.exception.SystemException, 157 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 158 return getPersistence().remove(frameworkVersionId); 159 } 160 161 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion updateImpl( 162 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion, 163 boolean merge) 164 throws com.liferay.portal.kernel.exception.SystemException { 165 return getPersistence().updateImpl(scFrameworkVersion, merge); 166 } 167 168 /** 169 * Returns the s c framework version with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException} if it could not be found. 170 * 171 * @param frameworkVersionId the primary key of the s c framework version 172 * @return the s c framework version 173 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 174 * @throws SystemException if a system exception occurred 175 */ 176 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByPrimaryKey( 177 long frameworkVersionId) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 180 return getPersistence().findByPrimaryKey(frameworkVersionId); 181 } 182 183 /** 184 * Returns the s c framework version with the primary key or returns <code>null</code> if it could not be found. 185 * 186 * @param frameworkVersionId the primary key of the s c framework version 187 * @return the s c framework version, or <code>null</code> if a s c framework version with the primary key could not be found 188 * @throws SystemException if a system exception occurred 189 */ 190 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchByPrimaryKey( 191 long frameworkVersionId) 192 throws com.liferay.portal.kernel.exception.SystemException { 193 return getPersistence().fetchByPrimaryKey(frameworkVersionId); 194 } 195 196 /** 197 * Returns all the s c framework versions where groupId = ?. 198 * 199 * @param groupId the group ID 200 * @return the matching s c framework versions 201 * @throws SystemException if a system exception occurred 202 */ 203 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId( 204 long groupId) 205 throws com.liferay.portal.kernel.exception.SystemException { 206 return getPersistence().findByGroupId(groupId); 207 } 208 209 /** 210 * Returns a range of all the s c framework versions where groupId = ?. 211 * 212 * <p> 213 * 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. 214 * </p> 215 * 216 * @param groupId the group ID 217 * @param start the lower bound of the range of s c framework versions 218 * @param end the upper bound of the range of s c framework versions (not inclusive) 219 * @return the range of matching s c framework versions 220 * @throws SystemException if a system exception occurred 221 */ 222 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId( 223 long groupId, int start, int end) 224 throws com.liferay.portal.kernel.exception.SystemException { 225 return getPersistence().findByGroupId(groupId, start, end); 226 } 227 228 /** 229 * Returns an ordered range of all the s c framework versions where groupId = ?. 230 * 231 * <p> 232 * 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. 233 * </p> 234 * 235 * @param groupId the group ID 236 * @param start the lower bound of the range of s c framework versions 237 * @param end the upper bound of the range of s c framework versions (not inclusive) 238 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 239 * @return the ordered range of matching s c framework versions 240 * @throws SystemException if a system exception occurred 241 */ 242 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByGroupId( 243 long groupId, int start, int end, 244 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 245 throws com.liferay.portal.kernel.exception.SystemException { 246 return getPersistence() 247 .findByGroupId(groupId, start, end, orderByComparator); 248 } 249 250 /** 251 * Returns the first s c framework version in the ordered set where groupId = ?. 252 * 253 * <p> 254 * 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. 255 * </p> 256 * 257 * @param groupId the group ID 258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 259 * @return the first matching s c framework version 260 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 261 * @throws SystemException if a system exception occurred 262 */ 263 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByGroupId_First( 264 long groupId, 265 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 266 throws com.liferay.portal.kernel.exception.SystemException, 267 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 268 return getPersistence().findByGroupId_First(groupId, orderByComparator); 269 } 270 271 /** 272 * Returns the last s c framework version in the ordered set where groupId = ?. 273 * 274 * <p> 275 * 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. 276 * </p> 277 * 278 * @param groupId the group ID 279 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 280 * @return the last matching s c framework version 281 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 282 * @throws SystemException if a system exception occurred 283 */ 284 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByGroupId_Last( 285 long groupId, 286 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 287 throws com.liferay.portal.kernel.exception.SystemException, 288 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 289 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 290 } 291 292 /** 293 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ?. 294 * 295 * <p> 296 * 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. 297 * </p> 298 * 299 * @param frameworkVersionId the primary key of the current s c framework version 300 * @param groupId the group ID 301 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 302 * @return the previous, current, and next s c framework version 303 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 304 * @throws SystemException if a system exception occurred 305 */ 306 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByGroupId_PrevAndNext( 307 long frameworkVersionId, long groupId, 308 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 309 throws com.liferay.portal.kernel.exception.SystemException, 310 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 311 return getPersistence() 312 .findByGroupId_PrevAndNext(frameworkVersionId, groupId, 313 orderByComparator); 314 } 315 316 /** 317 * Returns all the s c framework versions that the user has permission to view where groupId = ?. 318 * 319 * @param groupId the group ID 320 * @return the matching s c framework versions that the user has permission to view 321 * @throws SystemException if a system exception occurred 322 */ 323 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId( 324 long groupId) 325 throws com.liferay.portal.kernel.exception.SystemException { 326 return getPersistence().filterFindByGroupId(groupId); 327 } 328 329 /** 330 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ?. 331 * 332 * <p> 333 * 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. 334 * </p> 335 * 336 * @param groupId the group ID 337 * @param start the lower bound of the range of s c framework versions 338 * @param end the upper bound of the range of s c framework versions (not inclusive) 339 * @return the range of matching s c framework versions that the user has permission to view 340 * @throws SystemException if a system exception occurred 341 */ 342 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId( 343 long groupId, int start, int end) 344 throws com.liferay.portal.kernel.exception.SystemException { 345 return getPersistence().filterFindByGroupId(groupId, start, end); 346 } 347 348 /** 349 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ?. 350 * 351 * <p> 352 * 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. 353 * </p> 354 * 355 * @param groupId the group ID 356 * @param start the lower bound of the range of s c framework versions 357 * @param end the upper bound of the range of s c framework versions (not inclusive) 358 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 359 * @return the ordered range of matching s c framework versions that the user has permission to view 360 * @throws SystemException if a system exception occurred 361 */ 362 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByGroupId( 363 long groupId, int start, int end, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence() 367 .filterFindByGroupId(groupId, start, end, orderByComparator); 368 } 369 370 /** 371 * Returns the s c framework versions before and after the current s c framework version in the ordered set of s c framework versions that the user has permission to view where groupId = ?. 372 * 373 * @param frameworkVersionId the primary key of the current s c framework version 374 * @param groupId the group ID 375 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 376 * @return the previous, current, and next s c framework version 377 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 378 * @throws SystemException if a system exception occurred 379 */ 380 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByGroupId_PrevAndNext( 381 long frameworkVersionId, long groupId, 382 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 383 throws com.liferay.portal.kernel.exception.SystemException, 384 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 385 return getPersistence() 386 .filterFindByGroupId_PrevAndNext(frameworkVersionId, 387 groupId, orderByComparator); 388 } 389 390 /** 391 * Returns all the s c framework versions where companyId = ?. 392 * 393 * @param companyId the company ID 394 * @return the matching s c framework versions 395 * @throws SystemException if a system exception occurred 396 */ 397 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 398 long companyId) 399 throws com.liferay.portal.kernel.exception.SystemException { 400 return getPersistence().findByCompanyId(companyId); 401 } 402 403 /** 404 * Returns a range of all the s c framework versions where companyId = ?. 405 * 406 * <p> 407 * 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. 408 * </p> 409 * 410 * @param companyId the company ID 411 * @param start the lower bound of the range of s c framework versions 412 * @param end the upper bound of the range of s c framework versions (not inclusive) 413 * @return the range of matching s c framework versions 414 * @throws SystemException if a system exception occurred 415 */ 416 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 417 long companyId, int start, int end) 418 throws com.liferay.portal.kernel.exception.SystemException { 419 return getPersistence().findByCompanyId(companyId, start, end); 420 } 421 422 /** 423 * Returns an ordered range of all the s c framework versions where companyId = ?. 424 * 425 * <p> 426 * 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. 427 * </p> 428 * 429 * @param companyId the company ID 430 * @param start the lower bound of the range of s c framework versions 431 * @param end the upper bound of the range of s c framework versions (not inclusive) 432 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 433 * @return the ordered range of matching s c framework versions 434 * @throws SystemException if a system exception occurred 435 */ 436 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByCompanyId( 437 long companyId, int start, int end, 438 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 439 throws com.liferay.portal.kernel.exception.SystemException { 440 return getPersistence() 441 .findByCompanyId(companyId, start, end, orderByComparator); 442 } 443 444 /** 445 * Returns the first s c framework version in the ordered set where companyId = ?. 446 * 447 * <p> 448 * 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. 449 * </p> 450 * 451 * @param companyId the company ID 452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 453 * @return the first matching s c framework version 454 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 455 * @throws SystemException if a system exception occurred 456 */ 457 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_First( 458 long companyId, 459 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 460 throws com.liferay.portal.kernel.exception.SystemException, 461 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 462 return getPersistence() 463 .findByCompanyId_First(companyId, orderByComparator); 464 } 465 466 /** 467 * Returns the last s c framework version in the ordered set where companyId = ?. 468 * 469 * <p> 470 * 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. 471 * </p> 472 * 473 * @param companyId the company ID 474 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 475 * @return the last matching s c framework version 476 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 477 * @throws SystemException if a system exception occurred 478 */ 479 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByCompanyId_Last( 480 long companyId, 481 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 482 throws com.liferay.portal.kernel.exception.SystemException, 483 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 484 return getPersistence() 485 .findByCompanyId_Last(companyId, orderByComparator); 486 } 487 488 /** 489 * Returns the s c framework versions before and after the current s c framework version in the ordered set where companyId = ?. 490 * 491 * <p> 492 * 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. 493 * </p> 494 * 495 * @param frameworkVersionId the primary key of the current s c framework version 496 * @param companyId the company ID 497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 498 * @return the previous, current, and next s c framework version 499 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 500 * @throws SystemException if a system exception occurred 501 */ 502 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByCompanyId_PrevAndNext( 503 long frameworkVersionId, long companyId, 504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 505 throws com.liferay.portal.kernel.exception.SystemException, 506 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 507 return getPersistence() 508 .findByCompanyId_PrevAndNext(frameworkVersionId, companyId, 509 orderByComparator); 510 } 511 512 /** 513 * Returns all the s c framework versions where groupId = ? and active = ?. 514 * 515 * @param groupId the group ID 516 * @param active the active 517 * @return the matching s c framework versions 518 * @throws SystemException if a system exception occurred 519 */ 520 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 521 long groupId, boolean active) 522 throws com.liferay.portal.kernel.exception.SystemException { 523 return getPersistence().findByG_A(groupId, active); 524 } 525 526 /** 527 * Returns a range of all the s c framework versions where groupId = ? and active = ?. 528 * 529 * <p> 530 * 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. 531 * </p> 532 * 533 * @param groupId the group ID 534 * @param active the active 535 * @param start the lower bound of the range of s c framework versions 536 * @param end the upper bound of the range of s c framework versions (not inclusive) 537 * @return the range of matching s c framework versions 538 * @throws SystemException if a system exception occurred 539 */ 540 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 541 long groupId, boolean active, int start, int end) 542 throws com.liferay.portal.kernel.exception.SystemException { 543 return getPersistence().findByG_A(groupId, active, start, end); 544 } 545 546 /** 547 * Returns an ordered range of all the s c framework versions where groupId = ? and active = ?. 548 * 549 * <p> 550 * 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. 551 * </p> 552 * 553 * @param groupId the group ID 554 * @param active the active 555 * @param start the lower bound of the range of s c framework versions 556 * @param end the upper bound of the range of s c framework versions (not inclusive) 557 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 558 * @return the ordered range of matching s c framework versions 559 * @throws SystemException if a system exception occurred 560 */ 561 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findByG_A( 562 long groupId, boolean active, int start, int end, 563 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 564 throws com.liferay.portal.kernel.exception.SystemException { 565 return getPersistence() 566 .findByG_A(groupId, active, start, end, orderByComparator); 567 } 568 569 /** 570 * Returns the first s c framework version in the ordered set where groupId = ? and active = ?. 571 * 572 * <p> 573 * 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. 574 * </p> 575 * 576 * @param groupId the group ID 577 * @param active the active 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching s c framework version 580 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_First( 584 long groupId, boolean active, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 588 return getPersistence() 589 .findByG_A_First(groupId, active, orderByComparator); 590 } 591 592 /** 593 * Returns the last s c framework version in the ordered set where groupId = ? and active = ?. 594 * 595 * <p> 596 * 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. 597 * </p> 598 * 599 * @param groupId the group ID 600 * @param active the active 601 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 602 * @return the last matching s c framework version 603 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a matching s c framework version could not be found 604 * @throws SystemException if a system exception occurred 605 */ 606 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion findByG_A_Last( 607 long groupId, boolean active, 608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 609 throws com.liferay.portal.kernel.exception.SystemException, 610 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 611 return getPersistence() 612 .findByG_A_Last(groupId, active, orderByComparator); 613 } 614 615 /** 616 * Returns the s c framework versions before and after the current s c framework version in the ordered set where groupId = ? and active = ?. 617 * 618 * <p> 619 * 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. 620 * </p> 621 * 622 * @param frameworkVersionId the primary key of the current s c framework version 623 * @param groupId the group ID 624 * @param active the active 625 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 626 * @return the previous, current, and next s c framework version 627 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 628 * @throws SystemException if a system exception occurred 629 */ 630 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] findByG_A_PrevAndNext( 631 long frameworkVersionId, long groupId, boolean active, 632 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 633 throws com.liferay.portal.kernel.exception.SystemException, 634 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 635 return getPersistence() 636 .findByG_A_PrevAndNext(frameworkVersionId, groupId, active, 637 orderByComparator); 638 } 639 640 /** 641 * Returns all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 642 * 643 * @param groupId the group ID 644 * @param active the active 645 * @return the matching s c framework versions that the user has permission to view 646 * @throws SystemException if a system exception occurred 647 */ 648 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 649 long groupId, boolean active) 650 throws com.liferay.portal.kernel.exception.SystemException { 651 return getPersistence().filterFindByG_A(groupId, active); 652 } 653 654 /** 655 * Returns a range of all the s c framework versions that the user has permission to view where groupId = ? and active = ?. 656 * 657 * <p> 658 * 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. 659 * </p> 660 * 661 * @param groupId the group ID 662 * @param active the active 663 * @param start the lower bound of the range of s c framework versions 664 * @param end the upper bound of the range of s c framework versions (not inclusive) 665 * @return the range of matching s c framework versions that the user has permission to view 666 * @throws SystemException if a system exception occurred 667 */ 668 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 669 long groupId, boolean active, int start, int end) 670 throws com.liferay.portal.kernel.exception.SystemException { 671 return getPersistence().filterFindByG_A(groupId, active, start, end); 672 } 673 674 /** 675 * Returns an ordered range of all the s c framework versions that the user has permissions to view where groupId = ? and active = ?. 676 * 677 * <p> 678 * 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. 679 * </p> 680 * 681 * @param groupId the group ID 682 * @param active the active 683 * @param start the lower bound of the range of s c framework versions 684 * @param end the upper bound of the range of s c framework versions (not inclusive) 685 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 686 * @return the ordered range of matching s c framework versions that the user has permission to view 687 * @throws SystemException if a system exception occurred 688 */ 689 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> filterFindByG_A( 690 long groupId, boolean active, int start, int end, 691 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 692 throws com.liferay.portal.kernel.exception.SystemException { 693 return getPersistence() 694 .filterFindByG_A(groupId, active, start, end, 695 orderByComparator); 696 } 697 698 /** 699 * Returns the s c framework versions before and after the current s c framework version in the ordered set of s c framework versions that the user has permission to view where groupId = ? and active = ?. 700 * 701 * @param frameworkVersionId the primary key of the current s c framework version 702 * @param groupId the group ID 703 * @param active the active 704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 705 * @return the previous, current, and next s c framework version 706 * @throws com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException if a s c framework version with the primary key could not be found 707 * @throws SystemException if a system exception occurred 708 */ 709 public static com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion[] filterFindByG_A_PrevAndNext( 710 long frameworkVersionId, long groupId, boolean active, 711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 712 throws com.liferay.portal.kernel.exception.SystemException, 713 com.liferay.portlet.softwarecatalog.NoSuchFrameworkVersionException { 714 return getPersistence() 715 .filterFindByG_A_PrevAndNext(frameworkVersionId, groupId, 716 active, orderByComparator); 717 } 718 719 /** 720 * Returns all the s c framework versions. 721 * 722 * @return the s c framework versions 723 * @throws SystemException if a system exception occurred 724 */ 725 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll() 726 throws com.liferay.portal.kernel.exception.SystemException { 727 return getPersistence().findAll(); 728 } 729 730 /** 731 * Returns a range of all the s c framework versions. 732 * 733 * <p> 734 * 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. 735 * </p> 736 * 737 * @param start the lower bound of the range of s c framework versions 738 * @param end the upper bound of the range of s c framework versions (not inclusive) 739 * @return the range of s c framework versions 740 * @throws SystemException if a system exception occurred 741 */ 742 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll( 743 int start, int end) 744 throws com.liferay.portal.kernel.exception.SystemException { 745 return getPersistence().findAll(start, end); 746 } 747 748 /** 749 * Returns an ordered range of all the s c framework versions. 750 * 751 * <p> 752 * 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. 753 * </p> 754 * 755 * @param start the lower bound of the range of s c framework versions 756 * @param end the upper bound of the range of s c framework versions (not inclusive) 757 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 758 * @return the ordered range of s c framework versions 759 * @throws SystemException if a system exception occurred 760 */ 761 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> findAll( 762 int start, int end, 763 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 764 throws com.liferay.portal.kernel.exception.SystemException { 765 return getPersistence().findAll(start, end, orderByComparator); 766 } 767 768 /** 769 * Removes all the s c framework versions where groupId = ? from the database. 770 * 771 * @param groupId the group ID 772 * @throws SystemException if a system exception occurred 773 */ 774 public static void removeByGroupId(long groupId) 775 throws com.liferay.portal.kernel.exception.SystemException { 776 getPersistence().removeByGroupId(groupId); 777 } 778 779 /** 780 * Removes all the s c framework versions where companyId = ? from the database. 781 * 782 * @param companyId the company ID 783 * @throws SystemException if a system exception occurred 784 */ 785 public static void removeByCompanyId(long companyId) 786 throws com.liferay.portal.kernel.exception.SystemException { 787 getPersistence().removeByCompanyId(companyId); 788 } 789 790 /** 791 * Removes all the s c framework versions where groupId = ? and active = ? from the database. 792 * 793 * @param groupId the group ID 794 * @param active the active 795 * @throws SystemException if a system exception occurred 796 */ 797 public static void removeByG_A(long groupId, boolean active) 798 throws com.liferay.portal.kernel.exception.SystemException { 799 getPersistence().removeByG_A(groupId, active); 800 } 801 802 /** 803 * Removes all the s c framework versions from the database. 804 * 805 * @throws SystemException if a system exception occurred 806 */ 807 public static void removeAll() 808 throws com.liferay.portal.kernel.exception.SystemException { 809 getPersistence().removeAll(); 810 } 811 812 /** 813 * Returns the number of s c framework versions where groupId = ?. 814 * 815 * @param groupId the group ID 816 * @return the number of matching s c framework versions 817 * @throws SystemException if a system exception occurred 818 */ 819 public static int countByGroupId(long groupId) 820 throws com.liferay.portal.kernel.exception.SystemException { 821 return getPersistence().countByGroupId(groupId); 822 } 823 824 /** 825 * Returns the number of s c framework versions that the user has permission to view where groupId = ?. 826 * 827 * @param groupId the group ID 828 * @return the number of matching s c framework versions that the user has permission to view 829 * @throws SystemException if a system exception occurred 830 */ 831 public static int filterCountByGroupId(long groupId) 832 throws com.liferay.portal.kernel.exception.SystemException { 833 return getPersistence().filterCountByGroupId(groupId); 834 } 835 836 /** 837 * Returns the number of s c framework versions where companyId = ?. 838 * 839 * @param companyId the company ID 840 * @return the number of matching s c framework versions 841 * @throws SystemException if a system exception occurred 842 */ 843 public static int countByCompanyId(long companyId) 844 throws com.liferay.portal.kernel.exception.SystemException { 845 return getPersistence().countByCompanyId(companyId); 846 } 847 848 /** 849 * Returns the number of s c framework versions where groupId = ? and active = ?. 850 * 851 * @param groupId the group ID 852 * @param active the active 853 * @return the number of matching s c framework versions 854 * @throws SystemException if a system exception occurred 855 */ 856 public static int countByG_A(long groupId, boolean active) 857 throws com.liferay.portal.kernel.exception.SystemException { 858 return getPersistence().countByG_A(groupId, active); 859 } 860 861 /** 862 * Returns the number of s c framework versions that the user has permission to view where groupId = ? and active = ?. 863 * 864 * @param groupId the group ID 865 * @param active the active 866 * @return the number of matching s c framework versions that the user has permission to view 867 * @throws SystemException if a system exception occurred 868 */ 869 public static int filterCountByG_A(long groupId, boolean active) 870 throws com.liferay.portal.kernel.exception.SystemException { 871 return getPersistence().filterCountByG_A(groupId, active); 872 } 873 874 /** 875 * Returns the number of s c framework versions. 876 * 877 * @return the number of s c framework versions 878 * @throws SystemException if a system exception occurred 879 */ 880 public static int countAll() 881 throws com.liferay.portal.kernel.exception.SystemException { 882 return getPersistence().countAll(); 883 } 884 885 /** 886 * Returns all the s c product versions associated with the s c framework version. 887 * 888 * @param pk the primary key of the s c framework version 889 * @return the s c product versions associated with the s c framework version 890 * @throws SystemException if a system exception occurred 891 */ 892 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 893 long pk) throws com.liferay.portal.kernel.exception.SystemException { 894 return getPersistence().getSCProductVersions(pk); 895 } 896 897 /** 898 * Returns a range of all the s c product versions associated with the s c framework version. 899 * 900 * <p> 901 * 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. 902 * </p> 903 * 904 * @param pk the primary key of the s c framework version 905 * @param start the lower bound of the range of s c framework versions 906 * @param end the upper bound of the range of s c framework versions (not inclusive) 907 * @return the range of s c product versions associated with the s c framework version 908 * @throws SystemException if a system exception occurred 909 */ 910 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 911 long pk, int start, int end) 912 throws com.liferay.portal.kernel.exception.SystemException { 913 return getPersistence().getSCProductVersions(pk, start, end); 914 } 915 916 /** 917 * Returns an ordered range of all the s c product versions associated with the s c framework version. 918 * 919 * <p> 920 * 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. 921 * </p> 922 * 923 * @param pk the primary key of the s c framework version 924 * @param start the lower bound of the range of s c framework versions 925 * @param end the upper bound of the range of s c framework versions (not inclusive) 926 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 927 * @return the ordered range of s c product versions associated with the s c framework version 928 * @throws SystemException if a system exception occurred 929 */ 930 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> getSCProductVersions( 931 long pk, int start, int end, 932 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 933 throws com.liferay.portal.kernel.exception.SystemException { 934 return getPersistence() 935 .getSCProductVersions(pk, start, end, orderByComparator); 936 } 937 938 /** 939 * Returns the number of s c product versions associated with the s c framework version. 940 * 941 * @param pk the primary key of the s c framework version 942 * @return the number of s c product versions associated with the s c framework version 943 * @throws SystemException if a system exception occurred 944 */ 945 public static int getSCProductVersionsSize(long pk) 946 throws com.liferay.portal.kernel.exception.SystemException { 947 return getPersistence().getSCProductVersionsSize(pk); 948 } 949 950 /** 951 * Returns <code>true</code> if the s c product version is associated with the s c framework version. 952 * 953 * @param pk the primary key of the s c framework version 954 * @param scProductVersionPK the primary key of the s c product version 955 * @return <code>true</code> if the s c product version is associated with the s c framework version; <code>false</code> otherwise 956 * @throws SystemException if a system exception occurred 957 */ 958 public static boolean containsSCProductVersion(long pk, 959 long scProductVersionPK) 960 throws com.liferay.portal.kernel.exception.SystemException { 961 return getPersistence().containsSCProductVersion(pk, scProductVersionPK); 962 } 963 964 /** 965 * Returns <code>true</code> if the s c framework version has any s c product versions associated with it. 966 * 967 * @param pk the primary key of the s c framework version to check for associations with s c product versions 968 * @return <code>true</code> if the s c framework version has any s c product versions associated with it; <code>false</code> otherwise 969 * @throws SystemException if a system exception occurred 970 */ 971 public static boolean containsSCProductVersions(long pk) 972 throws com.liferay.portal.kernel.exception.SystemException { 973 return getPersistence().containsSCProductVersions(pk); 974 } 975 976 /** 977 * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 978 * 979 * @param pk the primary key of the s c framework version 980 * @param scProductVersionPK the primary key of the s c product version 981 * @throws SystemException if a system exception occurred 982 */ 983 public static void addSCProductVersion(long pk, long scProductVersionPK) 984 throws com.liferay.portal.kernel.exception.SystemException { 985 getPersistence().addSCProductVersion(pk, scProductVersionPK); 986 } 987 988 /** 989 * Adds an association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 990 * 991 * @param pk the primary key of the s c framework version 992 * @param scProductVersion the s c product version 993 * @throws SystemException if a system exception occurred 994 */ 995 public static void addSCProductVersion(long pk, 996 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 997 throws com.liferay.portal.kernel.exception.SystemException { 998 getPersistence().addSCProductVersion(pk, scProductVersion); 999 } 1000 1001 /** 1002 * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1003 * 1004 * @param pk the primary key of the s c framework version 1005 * @param scProductVersionPKs the primary keys of the s c product versions 1006 * @throws SystemException if a system exception occurred 1007 */ 1008 public static void addSCProductVersions(long pk, long[] scProductVersionPKs) 1009 throws com.liferay.portal.kernel.exception.SystemException { 1010 getPersistence().addSCProductVersions(pk, scProductVersionPKs); 1011 } 1012 1013 /** 1014 * Adds an association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1015 * 1016 * @param pk the primary key of the s c framework version 1017 * @param scProductVersions the s c product versions 1018 * @throws SystemException if a system exception occurred 1019 */ 1020 public static void addSCProductVersions(long pk, 1021 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 1022 throws com.liferay.portal.kernel.exception.SystemException { 1023 getPersistence().addSCProductVersions(pk, scProductVersions); 1024 } 1025 1026 /** 1027 * Clears all associations between the s c framework version and its s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1028 * 1029 * @param pk the primary key of the s c framework version to clear the associated s c product versions from 1030 * @throws SystemException if a system exception occurred 1031 */ 1032 public static void clearSCProductVersions(long pk) 1033 throws com.liferay.portal.kernel.exception.SystemException { 1034 getPersistence().clearSCProductVersions(pk); 1035 } 1036 1037 /** 1038 * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1039 * 1040 * @param pk the primary key of the s c framework version 1041 * @param scProductVersionPK the primary key of the s c product version 1042 * @throws SystemException if a system exception occurred 1043 */ 1044 public static void removeSCProductVersion(long pk, long scProductVersionPK) 1045 throws com.liferay.portal.kernel.exception.SystemException { 1046 getPersistence().removeSCProductVersion(pk, scProductVersionPK); 1047 } 1048 1049 /** 1050 * Removes the association between the s c framework version and the s c product version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1051 * 1052 * @param pk the primary key of the s c framework version 1053 * @param scProductVersion the s c product version 1054 * @throws SystemException if a system exception occurred 1055 */ 1056 public static void removeSCProductVersion(long pk, 1057 com.liferay.portlet.softwarecatalog.model.SCProductVersion scProductVersion) 1058 throws com.liferay.portal.kernel.exception.SystemException { 1059 getPersistence().removeSCProductVersion(pk, scProductVersion); 1060 } 1061 1062 /** 1063 * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1064 * 1065 * @param pk the primary key of the s c framework version 1066 * @param scProductVersionPKs the primary keys of the s c product versions 1067 * @throws SystemException if a system exception occurred 1068 */ 1069 public static void removeSCProductVersions(long pk, 1070 long[] scProductVersionPKs) 1071 throws com.liferay.portal.kernel.exception.SystemException { 1072 getPersistence().removeSCProductVersions(pk, scProductVersionPKs); 1073 } 1074 1075 /** 1076 * Removes the association between the s c framework version and the s c product versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1077 * 1078 * @param pk the primary key of the s c framework version 1079 * @param scProductVersions the s c product versions 1080 * @throws SystemException if a system exception occurred 1081 */ 1082 public static void removeSCProductVersions(long pk, 1083 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 1084 throws com.liferay.portal.kernel.exception.SystemException { 1085 getPersistence().removeSCProductVersions(pk, scProductVersions); 1086 } 1087 1088 /** 1089 * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1090 * 1091 * @param pk the primary key of the s c framework version 1092 * @param scProductVersionPKs the primary keys of the s c product versions to be associated with the s c framework version 1093 * @throws SystemException if a system exception occurred 1094 */ 1095 public static void setSCProductVersions(long pk, long[] scProductVersionPKs) 1096 throws com.liferay.portal.kernel.exception.SystemException { 1097 getPersistence().setSCProductVersions(pk, scProductVersionPKs); 1098 } 1099 1100 /** 1101 * Sets the s c product versions associated with the s c framework version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1102 * 1103 * @param pk the primary key of the s c framework version 1104 * @param scProductVersions the s c product versions to be associated with the s c framework version 1105 * @throws SystemException if a system exception occurred 1106 */ 1107 public static void setSCProductVersions(long pk, 1108 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductVersion> scProductVersions) 1109 throws com.liferay.portal.kernel.exception.SystemException { 1110 getPersistence().setSCProductVersions(pk, scProductVersions); 1111 } 1112 1113 public static SCFrameworkVersionPersistence getPersistence() { 1114 if (_persistence == null) { 1115 _persistence = (SCFrameworkVersionPersistence)PortalBeanLocatorUtil.locate(SCFrameworkVersionPersistence.class.getName()); 1116 1117 ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class, 1118 "_persistence"); 1119 } 1120 1121 return _persistence; 1122 } 1123 1124 public void setPersistence(SCFrameworkVersionPersistence persistence) { 1125 _persistence = persistence; 1126 1127 ReferenceRegistry.registerReference(SCFrameworkVersionUtil.class, 1128 "_persistence"); 1129 } 1130 1131 private static SCFrameworkVersionPersistence _persistence; 1132 }