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