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